@revenexx/node 0.0.2 → 0.1.0

package/dist/services/payments-methods.d.ts

@@ -0,0 +1,469 @@
+import { Client } from '../client.js';
+import { Models } from '../models.js';
+import { PaymentMethodKind } from '../enums/payment-method-kind.js';
+import { PaymentFeeType } from '../enums/payment-fee-type.js';
+import '../query.js';
+import '../enums/address-type-row-tone.js';
+import '../enums/address-type-row-create-request-tone.js';
+import '../enums/address-type-row-update-request-tone.js';
+import '../enums/assets-source.js';
+import '../enums/attribute-value-bucket.js';
+import '../enums/auth-mail-source.js';
+import '../enums/recovery-mail-source.js';
+import '../enums/registration-status.js';
+import '../enums/budget-change-reason.js';
+import '../enums/budget-movement-result-status.js';
+import '../enums/cart-status.js';
+import '../enums/cart-merge-strategy.js';
+import '../enums/cart-price-snapshot-mode.js';
+import '../enums/cart-io-format.js';
+import '../enums/cart-export-format.js';
+import '../enums/cart-item-type.js';
+import '../enums/cart-vocabulary-tone.js';
+import '../enums/cart-vocabulary-name.js';
+import '../enums/cart-vocabulary-source.js';
+import '../enums/cart-vocabulary-ref-name.js';
+import '../enums/categories-rule-match.js';
+import '../enums/category-rule-operator.js';
+import '../enums/category-rule-match.js';
+import '../enums/channel-status.js';
+import '../enums/channel-unassigned-visibility.js';
+import '../enums/channel-unresolved-reason.js';
+import '../enums/channel-context-source.js';
+import '../enums/channel-inactive-behavior.js';
+import '../enums/channel-policy-source.js';
+import '../enums/channel-policy-tenant-default.js';
+import '../enums/channel-unassigned-policy.js';
+import '../enums/channel-type-tone.js';
+import '../enums/channel-visibility-reason.js';
+import '../enums/channel-vocabulary-tone.js';
+import '../enums/channel-vocabulary-name.js';
+import '../enums/channel-vocabulary-source.js';
+import '../enums/channel-vocabulary-ref-name.js';
+import '../enums/contact-registration-status.js';
+import '../enums/contact-status.js';
+import '../enums/contact-activity-kind.js';
+import '../enums/contact-create-request-registration-status.js';
+import '../enums/contact-event-kind-tone.js';
+import '../enums/contact-event-kind-create-request-tone.js';
+import '../enums/contact-event-kind-update-request-tone.js';
+import '../enums/contact-update-request-registration-status.js';
+import '../enums/cost-center-budget-type.js';
+import '../enums/cost-center-restriction-type.js';
+import '../enums/cost-center-restriction-create-request-type.js';
+import '../enums/cost-center-restriction-update-request-type.js';
+import '../enums/form-status.js';
+import '../enums/form-submission-status.js';
+import '../enums/form-notify-source.js';
+import '../enums/form-submission-prune-request-status.js';
+import '../enums/forms-vocabulary-tone.js';
+import '../enums/forms-vocabulary-name.js';
+import '../enums/forms-vocabulary-summary-name.js';
+import '../enums/inventory-vocabulary-default-tone.js';
+import '../enums/inventory-vocabulary-source.js';
+import '../enums/cart-io-apply-mode.js';
+import '../enums/cart-io-direction.js';
+import '../enums/cart-io-entity.js';
+import '../enums/io-profile-resource-apply-mode.js';
+import '../enums/io-profile-resource-direction.js';
+import '../enums/lifecycle-stage-tone.js';
+import '../enums/lifecycle-stage-create-request-tone.js';
+import '../enums/lifecycle-stage-update-request-tone.js';
+import '../enums/location-type.js';
+import '../enums/market-status.js';
+import '../enums/market-default-locale-source.js';
+import '../enums/market-locale-fallback.js';
+import '../enums/market-locale-granularity.js';
+import '../enums/market-pricing-source.js';
+import '../enums/market-tax-basis.js';
+import '../enums/market-readiness-check-id.js';
+import '../enums/market-readiness-severity.js';
+import '../enums/markets-vocabulary-tone.js';
+import '../enums/markets-vocabulary-name.js';
+import '../enums/markets-vocabulary-source.js';
+import '../enums/markets-vocabulary-summary-name.js';
+import '../enums/order-fulfillment-status.js';
+import '../enums/order-payment-status.js';
+import '../enums/order-status.js';
+import '../enums/order-cancellation-scope.js';
+import '../enums/order-comment-visibility.js';
+import '../enums/order-item-type.js';
+import '../enums/order-list-kind-tone.js';
+import '../enums/order-list-kind-row-tone.js';
+import '../enums/order-list-cart-mode.js';
+import '../enums/order-list-vocabulary-default-tone.js';
+import '../enums/order-list-vocabulary-name.js';
+import '../enums/order-list-vocabulary-source.js';
+import '../enums/order-list-vocabulary-tone.js';
+import '../enums/order-return-status.js';
+import '../enums/order-return-settlement.js';
+import '../enums/order-return-refusal.js';
+import '../enums/order-vocabulary-tone.js';
+import '../enums/order-vocabulary-name.js';
+import '../enums/order-vocabulary-source.js';
+import '../enums/order-vocabulary-summary-name.js';
+import '../enums/order-resolution-stage.js';
+import '../enums/organization-status.js';
+import '../enums/page-status.js';
+import '../enums/pages-vocabulary-app.js';
+import '../enums/pages-vocabulary-tone.js';
+import '../enums/pages-vocabulary-name.js';
+import '../enums/pages-vocabulary-source.js';
+import '../enums/pages-vocabulary-index-app.js';
+import '../enums/payment-dunning-stage.js';
+import '../enums/payment-failure-code.js';
+import '../enums/payment-status.js';
+import '../enums/payment-term-tone.js';
+import '../enums/payment-term-create-request-tone.js';
+import '../enums/payment-term-update-request-tone.js';
+import '../enums/payment-vocabulary-tone.js';
+import '../enums/price-ending-rule.js';
+import '../enums/price-entries-adjust-response-rounding.js';
+import '../enums/price-entries-adjust-response-rounding-mode.js';
+import '../enums/price-entries-bulk-mode.js';
+import '../enums/price-rounding-mode.js';
+import '../enums/price-entry-type.js';
+import '../enums/price-list-status.js';
+import '../enums/price-list-tax-basis.js';
+import '../enums/price-currency-source.js';
+import '../enums/price-list-tiebreak.js';
+import '../enums/price-tax-inclusive-default.js';
+import '../enums/price-tax-unresolved-reason.js';
+import '../enums/price-tax-market-source.js';
+import '../enums/price-vocabulary-tone.js';
+import '../enums/price-vocabulary-name.js';
+import '../enums/price-vocabulary-source.js';
+import '../enums/price-vocabulary-ref-name.js';
+import '../enums/product-categories-source.js';
+import '../enums/product-grid-column-source.js';
+import '../enums/product-label-source.js';
+import '../enums/product-label-attribute-source.js';
+import '../enums/products-kind.js';
+import '../enums/reorder-point-source.js';
+import '../enums/reservation-status.js';
+import '../enums/price-on-request-reason.js';
+import '../enums/price-tax-basis.js';
+import '../enums/price-tax-basis-source.js';
+import '../enums/role-catalog-response-source.js';
+import '../enums/segment-rule-match.js';
+import '../enums/segment-member-source.js';
+import '../enums/segment-rule-operator.js';
+import '../enums/segment-rule-preview-request-rule-match.js';
+import '../enums/segment-rule-preview-request-target.js';
+import '../enums/segment-rule-preview-response-rule-match.js';
+import '../enums/segment-rule-preview-response-target.js';
+import '../enums/segment-rules-target.js';
+import '../enums/shipping-carrier-status.js';
+import '../enums/shipping-method-matrix-basis.js';
+import '../enums/shipping-method-pricing-type.js';
+import '../enums/shipping-carrier-source.js';
+import '../enums/shipping-rate-pricing-type.js';
+import '../enums/shipping-tax-source.js';
+import '../enums/shipping-free-above-basis.js';
+import '../enums/shipping-rates-basis-matrix-basis-default.js';
+import '../enums/shipping-service-level-create-request-tone.js';
+import '../enums/shipping-service-level-row-tone.js';
+import '../enums/shipping-service-level-update-request-tone.js';
+import '../enums/shipping-tax-unresolved-reason.js';
+import '../enums/shipping-tax-market-source.js';
+import '../enums/shipping-tax-context-via.js';
+import '../enums/shipping-tracking-carrier-status.js';
+import '../enums/shipping-vocabulary-default-tone.js';
+import '../enums/shipping-vocabulary-source.js';
+import '../enums/shipping-vocabulary-tone.js';
+import '../enums/shipping-weight-unit-create-request-tone.js';
+import '../enums/shipping-weight-unit-row-tone.js';
+import '../enums/shipping-weight-unit-update-request-tone.js';
+import '../enums/stock-movement-type.js';
+import '../enums/store-asset-request-visibility.js';
+import '../enums/validation-failed-response-status.js';
+import '../enums/vocabulary-default-tone.js';
+import '../enums/vocabulary-source.js';
+import '../enums/vocabulary-tone.js';
+import '../enums/attribute-boolean-status.js';
+import '../enums/attribute-datetime-status.js';
+import '../enums/attribute-email-status.js';
+import '../enums/attribute-enum-status.js';
+import '../enums/attribute-float-status.js';
+import '../enums/attribute-integer-status.js';
+import '../enums/attribute-ip-status.js';
+import '../enums/attribute-line-status.js';
+import '../enums/attribute-longtext-status.js';
+import '../enums/attribute-mediumtext-status.js';
+import '../enums/attribute-point-status.js';
+import '../enums/attribute-polygon-status.js';
+import '../enums/attribute-relationship-status.js';
+import '../enums/attribute-string-status.js';
+import '../enums/attribute-text-status.js';
+import '../enums/attribute-url-status.js';
+import '../enums/attribute-varchar-status.js';
+import '../enums/column-boolean-status.js';
+import '../enums/column-datetime-status.js';
+import '../enums/column-email-status.js';
+import '../enums/column-enum-status.js';
+import '../enums/column-float-status.js';
+import '../enums/column-integer-status.js';
+import '../enums/column-ip-status.js';
+import '../enums/column-line-status.js';
+import '../enums/column-longtext-status.js';
+import '../enums/column-mediumtext-status.js';
+import '../enums/column-point-status.js';
+import '../enums/column-polygon-status.js';
+import '../enums/column-relationship-status.js';
+import '../enums/column-string-status.js';
+import '../enums/column-text-status.js';
+import '../enums/column-url-status.js';
+import '../enums/column-varchar-status.js';
+import '../enums/database-type.js';
+import '../enums/deployment-status.js';
+import '../enums/execution-status.js';
+import '../enums/execution-trigger.js';
+import '../enums/health-antivirus-status.js';
+import '../enums/health-status-status.js';
+import '../enums/index-status.js';
+import '../enums/message-2-status.js';
+
+declare class PaymentsMethods {
+    client: Client;
+    constructor(client: Client);
+    /**
+     * Every method this tenant has configured, enabled or not — what the Cockpit's Payment methods screen shows and how an integration finds out which codes exist. It answers CONFIGURATION, never an offer: nothing here is evaluated against a buyer, so a method restricted to Germany, one whose order-value bounds exclude this basket and one whose PSP was never set up all come back the same way. The call a checkout makes is POST /payments/methods/eligible. Rows come back in whatever order the database returns them, so a storefront-shaped list needs `?order=position.asc` — `position` is the merchant's intended sequence and nothing sorts by it here on its own.
+     *
+     * @param {number} params.limit - Page size (default 50, max 200).
+     * @param {number} params.offset - Row offset for pagination (default 0).
+     * @param {string} params.order - Sort by one column: 'column' | 'column.asc' | 'column.desc'. A bare column sorts ascending. Anything else is refused with 400.
+     * @param {string} params.code - Exact method code.
+     * @param {PaymentMethodKind} params.kind - Restrict to self-managed or PSP-backed methods.
+     * @param {boolean} params.enabled - Restrict to enabled or disabled methods. Indexed.
+     * @param {string} params.provider - Exact PSP code.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    paymentsMethodsList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        code?: string;
+        kind?: PaymentMethodKind;
+        enabled?: boolean;
+        provider?: string;
+    }): Promise<{}>;
+    /**
+     * Every method this tenant has configured, enabled or not — what the Cockpit's Payment methods screen shows and how an integration finds out which codes exist. It answers CONFIGURATION, never an offer: nothing here is evaluated against a buyer, so a method restricted to Germany, one whose order-value bounds exclude this basket and one whose PSP was never set up all come back the same way. The call a checkout makes is POST /payments/methods/eligible. Rows come back in whatever order the database returns them, so a storefront-shaped list needs `?order=position.asc` — `position` is the merchant's intended sequence and nothing sorts by it here on its own.
+     *
+     * @param {number} limit - Page size (default 50, max 200).
+     * @param {number} offset - Row offset for pagination (default 0).
+     * @param {string} order - Sort by one column: 'column' | 'column.asc' | 'column.desc'. A bare column sorts ascending. Anything else is refused with 400.
+     * @param {string} code - Exact method code.
+     * @param {PaymentMethodKind} kind - Restrict to self-managed or PSP-backed methods.
+     * @param {boolean} enabled - Restrict to enabled or disabled methods. Indexed.
+     * @param {string} provider - Exact PSP code.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    paymentsMethodsList(limit?: number, offset?: number, order?: string, code?: string, kind?: PaymentMethodKind, enabled?: boolean, provider?: string): Promise<{}>;
+    /**
+     * Adds a line a checkout can offer. A create cannot omit `code` and `name`; every other column is optional or defaulted by the database. Two rows of this tenant may not share `code` — that is the 409. Two defaults are worth knowing before the first call: `enabled` is false, so a new method reaches no checkout until it is switched on, and `kind` is 'self_managed' — a card or wallet method needs `kind: "psp"` plus a `provider` the catalog carries, or it falls back to the tenant's `default_provider` at payment time and fails there if none is set. The `code` is the value every payment, every checkout and every ERP will name this method by from now on, and once a single payment has been made under it a rename is refused with 409: choose it once.
+     *
+     * @param {string} params.code - The machine name of the method, unique per tenant and lower case by convention ('invoice', 'prepayment', 'card', 'paypal'). It is the string the checkout asks for, the string every payment stores, and therefore the one value here that cannot be changed freely: renaming it would leave the ledger naming something that no longer exists, so it is refused with 409 for as long as any payment names it. Required on create.
+     * @param {string} params.name - Operator-facing name, in the language the merchant administers in. What a buyer sees comes from `labels`. Required on create.
+     * @param {string[]} params.countries - Allowed ISO 3166-1 alpha-2 country codes, compared upper-cased against the buyer country. null or an empty list means unrestricted — the invoice method this app seeds is restricted to DE, which is why an eligibility call without a country sees it excluded.
+     * @param {string} params.description - One line explaining the method where it is offered — payment terms, what happens after the order. Shown to the buyer, so it is the merchant's wording rather than the app's.
+     * @param {boolean} params.enabled - A disabled method is never eligible and never reaches a checkout. This is the switch an operator wants: deleting a method the ledger still names — or renaming its `code` — is refused with 409. Defaults to false, so a half-configured method cannot reach a checkout by accident.
+     * @param {number} params.feeAmount - The surcharge this method costs the buyer, read as an amount or as a percentage depending on `fee_type`. Never negative — a discount for paying a certain way is not expressible here. Defaults to 0.
+     * @param {string} params.feeCurrency - ISO 4217 code a fixed fee is expressed in. The database bounds the length at three characters and nothing else, so lower case is stored as written. Defaults to EUR, and lower case is accepted here exactly as the handlers accept it.
+     * @param {PaymentFeeType} params.feeType - How `fee_amount` applies: 'none' (no surcharge), 'fixed' (that many units of `fee_currency`) or 'percent' (that share of the order amount). Defaults to 'none'.
+     * @param {PaymentMethodKind} params.kind - Who moves the money. 'self_managed' — invoice, prepayment — means the merchant fulfils and reconciles it outside any PSP, and such a payment authorizes the moment it is created. 'psp' means a configured provider authorizes, captures and refunds it. Defaults to 'self_managed'; 'psp' needs a 'provider' to transact.
+     * @param {object} params.labels - Buyer-facing names keyed by language tag — what a storefront shows instead of the operator-facing `name`. Free jsonb: the database constrains neither the tags nor the values, so a client reads the tag it wants and falls back to `en`.
+     * @param {number} params.maxOrderValue - Largest order amount this method may be used for — the usual credit-risk cap on invoice and prepayment. null means no upper bound.
+     * @param {object} params.metadata - Free-form merchant data carried on the configuration. This app never reads it — it is storage for the integrations that do (an ERP key for the method, a ledger account, a display hint).
+     * @param {number} params.minOrderValue - Smallest order amount this method may be used for — the usual guard against paying a €5 order by invoice. null means no lower bound.
+     * @param {number} params.position - Sort order at checkout, ascending — the merchant's preferred payment method first. Defaults to 0.
+     * @param {string} params.provider - The PSP code this method transacts through, from GET /payments/providers/catalog. Only meaningful for kind 'psp'; a PSP method that names none falls back to the tenant's `default_provider` setting. Must be a code GET /payments/providers/catalog carries.
+     * @param {string} params.providerMethod - The provider's own payment-method id ('card', 'paypal', 'sepa_debit') — what the driver is told to charge. Copied onto every payment created with this method as `metadata.provider_method`.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    paymentsMethodsCreate(params: {
+        code: string;
+        name: string;
+        countries?: string[];
+        description?: string;
+        enabled?: boolean;
+        feeAmount?: number;
+        feeCurrency?: string;
+        feeType?: PaymentFeeType;
+        kind?: PaymentMethodKind;
+        labels?: object;
+        maxOrderValue?: number;
+        metadata?: object;
+        minOrderValue?: number;
+        position?: number;
+        provider?: string;
+        providerMethod?: string;
+    }): Promise<Models.Error>;
+    /**
+     * Adds a line a checkout can offer. A create cannot omit `code` and `name`; every other column is optional or defaulted by the database. Two rows of this tenant may not share `code` — that is the 409. Two defaults are worth knowing before the first call: `enabled` is false, so a new method reaches no checkout until it is switched on, and `kind` is 'self_managed' — a card or wallet method needs `kind: "psp"` plus a `provider` the catalog carries, or it falls back to the tenant's `default_provider` at payment time and fails there if none is set. The `code` is the value every payment, every checkout and every ERP will name this method by from now on, and once a single payment has been made under it a rename is refused with 409: choose it once.
+     *
+     * @param {string} code - The machine name of the method, unique per tenant and lower case by convention ('invoice', 'prepayment', 'card', 'paypal'). It is the string the checkout asks for, the string every payment stores, and therefore the one value here that cannot be changed freely: renaming it would leave the ledger naming something that no longer exists, so it is refused with 409 for as long as any payment names it. Required on create.
+     * @param {string} name - Operator-facing name, in the language the merchant administers in. What a buyer sees comes from `labels`. Required on create.
+     * @param {string[]} countries - Allowed ISO 3166-1 alpha-2 country codes, compared upper-cased against the buyer country. null or an empty list means unrestricted — the invoice method this app seeds is restricted to DE, which is why an eligibility call without a country sees it excluded.
+     * @param {string} description - One line explaining the method where it is offered — payment terms, what happens after the order. Shown to the buyer, so it is the merchant's wording rather than the app's.
+     * @param {boolean} enabled - A disabled method is never eligible and never reaches a checkout. This is the switch an operator wants: deleting a method the ledger still names — or renaming its `code` — is refused with 409. Defaults to false, so a half-configured method cannot reach a checkout by accident.
+     * @param {number} feeAmount - The surcharge this method costs the buyer, read as an amount or as a percentage depending on `fee_type`. Never negative — a discount for paying a certain way is not expressible here. Defaults to 0.
+     * @param {string} feeCurrency - ISO 4217 code a fixed fee is expressed in. The database bounds the length at three characters and nothing else, so lower case is stored as written. Defaults to EUR, and lower case is accepted here exactly as the handlers accept it.
+     * @param {PaymentFeeType} feeType - How `fee_amount` applies: 'none' (no surcharge), 'fixed' (that many units of `fee_currency`) or 'percent' (that share of the order amount). Defaults to 'none'.
+     * @param {PaymentMethodKind} kind - Who moves the money. 'self_managed' — invoice, prepayment — means the merchant fulfils and reconciles it outside any PSP, and such a payment authorizes the moment it is created. 'psp' means a configured provider authorizes, captures and refunds it. Defaults to 'self_managed'; 'psp' needs a 'provider' to transact.
+     * @param {object} labels - Buyer-facing names keyed by language tag — what a storefront shows instead of the operator-facing `name`. Free jsonb: the database constrains neither the tags nor the values, so a client reads the tag it wants and falls back to `en`.
+     * @param {number} maxOrderValue - Largest order amount this method may be used for — the usual credit-risk cap on invoice and prepayment. null means no upper bound.
+     * @param {object} metadata - Free-form merchant data carried on the configuration. This app never reads it — it is storage for the integrations that do (an ERP key for the method, a ledger account, a display hint).
+     * @param {number} minOrderValue - Smallest order amount this method may be used for — the usual guard against paying a €5 order by invoice. null means no lower bound.
+     * @param {number} position - Sort order at checkout, ascending — the merchant's preferred payment method first. Defaults to 0.
+     * @param {string} provider - The PSP code this method transacts through, from GET /payments/providers/catalog. Only meaningful for kind 'psp'; a PSP method that names none falls back to the tenant's `default_provider` setting. Must be a code GET /payments/providers/catalog carries.
+     * @param {string} providerMethod - The provider's own payment-method id ('card', 'paypal', 'sepa_debit') — what the driver is told to charge. Copied onto every payment created with this method as `metadata.provider_method`.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    paymentsMethodsCreate(code: string, name: string, countries?: string[], description?: string, enabled?: boolean, feeAmount?: number, feeCurrency?: string, feeType?: PaymentFeeType, kind?: PaymentMethodKind, labels?: object, maxOrderValue?: number, metadata?: object, minOrderValue?: number, position?: number, provider?: string, providerMethod?: string): Promise<Models.Error>;
+    /**
+     * Writes the four methods a shop starts with — invoice and prepayment as self-managed, card and PayPal routed at the mock PSP so a fresh install can complete a checkout end to end — together with the four provider rows behind them: the built-in mock plus Stripe, PayPal and Novalnet, the three connectors this app opens outbound. The app already runs this for itself when it is installed (it listens on app.installed), so calling the route is for the second time and after: a method someone deleted, or a row a later release added that an existing install never got. Stripe, PayPal and Novalnet arrive disabled, in test mode and without credentials — the operator fills those in — while the mock arrives enabled, because it moves no money. Re-running is safe by design: it never duplicates a row and never overwrites an existing one, so nothing an operator has set can be undone by calling it again. Only genuinely missing option keys (a logo added after the first install) are filled, and those rows are reported as "updated" rather than created.
+     *
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    paymentsMethodsDefaults(): Promise<{}>;
+    /**
+     * The checkout's question — "what can THIS buyer pay with?" — answered server-side before any PSP is involved, so the storefront never renders a method the create would then refuse with 422. It evaluates the buyer context against every configured method: disabled, a country outside `countries`, an amount outside `min_order_value`/`max_order_value`. Restriction dimensions are ANDed and entries within one are ORed, and an empty dimension means unrestricted. Eligible methods come back sorted by `position` with their fee already computed for this amount; everything else lands in `excluded` with the reason in words, which is what makes a support question answerable. It reads only — nothing is written and no provider is called. Two things it does NOT check: whether the method's PSP is configured and enabled (a method whose provider is switched off is still offered here and fails at POST /payments — a provider a method names can no longer be deleted, which closes the other half of the same gap), and anything about the buyer beyond country and amount. A context that matches nothing is 200 with an empty `methods` list, never 404.
+     *
+     * @param {number} params.amount - The order amount the order-value bounds are checked against and the percentage fees are computed from. Defaults to 0, which excludes every method carrying a minimum. Nothing is written, so the ledger's own amount bound does not apply here.
+     * @param {string} params.country - The buyer's ISO 3166-1 alpha-2 country code. A method restricted to countries is excluded without it — an unknown buyer sees only the unrestricted methods, which is the safe default and not a bug.
+     * @param {string} params.currency - ISO 4217 code the amount is in, echoed onto every computed fee. Defaults to EUR. This app does no conversion: the fee comes back in the currency it was asked with.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    paymentsMethodsEligible(params?: {
+        amount?: number;
+        country?: string;
+        currency?: string;
+    }): Promise<{}>;
+    /**
+     * The checkout's question — "what can THIS buyer pay with?" — answered server-side before any PSP is involved, so the storefront never renders a method the create would then refuse with 422. It evaluates the buyer context against every configured method: disabled, a country outside `countries`, an amount outside `min_order_value`/`max_order_value`. Restriction dimensions are ANDed and entries within one are ORed, and an empty dimension means unrestricted. Eligible methods come back sorted by `position` with their fee already computed for this amount; everything else lands in `excluded` with the reason in words, which is what makes a support question answerable. It reads only — nothing is written and no provider is called. Two things it does NOT check: whether the method's PSP is configured and enabled (a method whose provider is switched off is still offered here and fails at POST /payments — a provider a method names can no longer be deleted, which closes the other half of the same gap), and anything about the buyer beyond country and amount. A context that matches nothing is 200 with an empty `methods` list, never 404.
+     *
+     * @param {number} amount - The order amount the order-value bounds are checked against and the percentage fees are computed from. Defaults to 0, which excludes every method carrying a minimum. Nothing is written, so the ledger's own amount bound does not apply here.
+     * @param {string} country - The buyer's ISO 3166-1 alpha-2 country code. A method restricted to countries is excluded without it — an unknown buyer sees only the unrestricted methods, which is the safe default and not a bug.
+     * @param {string} currency - ISO 4217 code the amount is in, echoed onto every computed fee. Defaults to EUR. This app does no conversion: the fee comes back in the currency it was asked with.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    paymentsMethodsEligible(amount?: number, country?: string, currency?: string): Promise<{}>;
+    /**
+     * payments.method_code is a CODE, not a foreign key: a payment records what happened and has to survive the configuration it was made with. The cost of that looseness is that deleting a method turns every payment made with it into a row naming something that no longer exists. So the count is taken HERE and answered as 409 with the number, rather than left to whoever is about to click delete — a client that pre-counts asks a second question whose answer disagrees the moment a payment lands between the two calls. Disabling the method (enabled: false) is what an operator usually meant and stays available.
+     *
+     * @param {string} params.id - The payment method configuration. A uuid — the data plane casts this segment and answers 400, not 404, for anything else.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    paymentsMethodsDelete(params: {
+        id: string;
+    }): Promise<Models.Error>;
+    /**
+     * payments.method_code is a CODE, not a foreign key: a payment records what happened and has to survive the configuration it was made with. The cost of that looseness is that deleting a method turns every payment made with it into a row naming something that no longer exists. So the count is taken HERE and answered as 409 with the number, rather than left to whoever is about to click delete — a client that pre-counts asks a second question whose answer disagrees the moment a payment lands between the two calls. Disabling the method (enabled: false) is what an operator usually meant and stays available.
+     *
+     * @param {string} id - The payment method configuration. A uuid — the data plane casts this segment and answers 400, not 404, for anything else.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    paymentsMethodsDelete(id: string): Promise<Models.Error>;
+    /**
+     * One configuration, every column, addressed by its row id — the edit form's read. It is addressed by ID and there is no route that takes a `code`, which matters because the CODE is what a checkout, a payment and an ERP name a method by: to resolve one, filter the list (`GET /payments/methods?code=invoice`), which answers a page of at most one row because (tenant_id, code) is unique. Reading a method says nothing about whether a buyer may use it — that is POST /payments/methods/eligible — and nothing about whether its PSP can transact, which is under the provider configuration.
+     *
+     * @param {string} params.id - The payment method configuration. A uuid — the data plane casts this segment and answers 400, not 404, for anything else.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    paymentsMethodsGet(params: {
+        id: string;
+    }): Promise<Models.Error>;
+    /**
+     * One configuration, every column, addressed by its row id — the edit form's read. It is addressed by ID and there is no route that takes a `code`, which matters because the CODE is what a checkout, a payment and an ERP name a method by: to resolve one, filter the list (`GET /payments/methods?code=invoice`), which answers a page of at most one row because (tenant_id, code) is unique. Reading a method says nothing about whether a buyer may use it — that is POST /payments/methods/eligible — and nothing about whether its PSP can transact, which is under the provider configuration.
+     *
+     * @param {string} id - The payment method configuration. A uuid — the data plane casts this segment and answers 400, not 404, for anything else.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    paymentsMethodsGet(id: string): Promise<Models.Error>;
+    /**
+     * A PUT that PATCHES: only the keys in the body are written and every omitted column keeps its value, so `{"enabled": false}` is the whole request for taking a method out of checkout. A body with no writable key is refused with 400 rather than treated as a no-op. This is the route for all three things an operator changes about a method after it exists — the `enabled` switch that puts it in or out of checkout, the fee it charges (`fee_type`, `fee_amount`, `fee_currency`) and the restrictions that decide who is offered it (`countries`, `min_order_value`, `max_order_value`) — alongside its labels, description and `position`. `enabled: false` is the safe way to retire one — it disappears from POST /payments/methods/eligible immediately and stays on every payment ever made with it. The one write this route refuses is a rename of `code` while the ledger still names the old one. The three tables of this app carry no foreign keys at all: a payment names its method by `method_code` and its acquirer by `provider`, both plain text, because a payment records what happened and has to survive the configuration it was made with. So the database will not stop this — whatever the ledger still names, it goes on naming. A rename would therefore leave every recorded payment pointing at a code no configuration carries, which is the same harm DELETE on this row answers 409 for — so it answers the same 409, with the same `method_in_use` code and the same count. Renaming a method nothing has been paid with is still free, and so is every other column at any time.
+     *
+     * @param {string} params.id - The payment method configuration. A uuid — the data plane casts this segment and answers 400, not 404, for anything else.
+     * @param {string} params.code - The machine name of the method, unique per tenant and lower case by convention ('invoice', 'prepayment', 'card', 'paypal'). It is the string the checkout asks for, the string every payment stores, and therefore the one value here that cannot be changed freely: renaming it would leave the ledger naming something that no longer exists, so it is refused with 409 for as long as any payment names it. Required on create.
+     * @param {string[]} params.countries - Allowed ISO 3166-1 alpha-2 country codes, compared upper-cased against the buyer country. null or an empty list means unrestricted — the invoice method this app seeds is restricted to DE, which is why an eligibility call without a country sees it excluded.
+     * @param {string} params.description - One line explaining the method where it is offered — payment terms, what happens after the order. Shown to the buyer, so it is the merchant's wording rather than the app's.
+     * @param {boolean} params.enabled - A disabled method is never eligible and never reaches a checkout. This is the switch an operator wants: deleting a method the ledger still names — or renaming its `code` — is refused with 409. Defaults to false, so a half-configured method cannot reach a checkout by accident.
+     * @param {number} params.feeAmount - The surcharge this method costs the buyer, read as an amount or as a percentage depending on `fee_type`. Never negative — a discount for paying a certain way is not expressible here. Defaults to 0.
+     * @param {string} params.feeCurrency - ISO 4217 code a fixed fee is expressed in. The database bounds the length at three characters and nothing else, so lower case is stored as written. Defaults to EUR, and lower case is accepted here exactly as the handlers accept it.
+     * @param {PaymentFeeType} params.feeType - How `fee_amount` applies: 'none' (no surcharge), 'fixed' (that many units of `fee_currency`) or 'percent' (that share of the order amount). Defaults to 'none'.
+     * @param {PaymentMethodKind} params.kind - Who moves the money. 'self_managed' — invoice, prepayment — means the merchant fulfils and reconciles it outside any PSP, and such a payment authorizes the moment it is created. 'psp' means a configured provider authorizes, captures and refunds it. Defaults to 'self_managed'; 'psp' needs a 'provider' to transact.
+     * @param {object} params.labels - Buyer-facing names keyed by language tag — what a storefront shows instead of the operator-facing `name`. Free jsonb: the database constrains neither the tags nor the values, so a client reads the tag it wants and falls back to `en`.
+     * @param {number} params.maxOrderValue - Largest order amount this method may be used for — the usual credit-risk cap on invoice and prepayment. null means no upper bound.
+     * @param {object} params.metadata - Free-form merchant data carried on the configuration. This app never reads it — it is storage for the integrations that do (an ERP key for the method, a ledger account, a display hint).
+     * @param {number} params.minOrderValue - Smallest order amount this method may be used for — the usual guard against paying a €5 order by invoice. null means no lower bound.
+     * @param {string} params.name - Operator-facing name, in the language the merchant administers in. What a buyer sees comes from `labels`. Required on create.
+     * @param {number} params.position - Sort order at checkout, ascending — the merchant's preferred payment method first. Defaults to 0.
+     * @param {string} params.provider - The PSP code this method transacts through, from GET /payments/providers/catalog. Only meaningful for kind 'psp'; a PSP method that names none falls back to the tenant's `default_provider` setting. Must be a code GET /payments/providers/catalog carries.
+     * @param {string} params.providerMethod - The provider's own payment-method id ('card', 'paypal', 'sepa_debit') — what the driver is told to charge. Copied onto every payment created with this method as `metadata.provider_method`.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    paymentsMethodsUpdate(params: {
+        id: string;
+        code?: string;
+        countries?: string[];
+        description?: string;
+        enabled?: boolean;
+        feeAmount?: number;
+        feeCurrency?: string;
+        feeType?: PaymentFeeType;
+        kind?: PaymentMethodKind;
+        labels?: object;
+        maxOrderValue?: number;
+        metadata?: object;
+        minOrderValue?: number;
+        name?: string;
+        position?: number;
+        provider?: string;
+        providerMethod?: string;
+    }): Promise<Models.Error>;
+    /**
+     * A PUT that PATCHES: only the keys in the body are written and every omitted column keeps its value, so `{"enabled": false}` is the whole request for taking a method out of checkout. A body with no writable key is refused with 400 rather than treated as a no-op. This is the route for all three things an operator changes about a method after it exists — the `enabled` switch that puts it in or out of checkout, the fee it charges (`fee_type`, `fee_amount`, `fee_currency`) and the restrictions that decide who is offered it (`countries`, `min_order_value`, `max_order_value`) — alongside its labels, description and `position`. `enabled: false` is the safe way to retire one — it disappears from POST /payments/methods/eligible immediately and stays on every payment ever made with it. The one write this route refuses is a rename of `code` while the ledger still names the old one. The three tables of this app carry no foreign keys at all: a payment names its method by `method_code` and its acquirer by `provider`, both plain text, because a payment records what happened and has to survive the configuration it was made with. So the database will not stop this — whatever the ledger still names, it goes on naming. A rename would therefore leave every recorded payment pointing at a code no configuration carries, which is the same harm DELETE on this row answers 409 for — so it answers the same 409, with the same `method_in_use` code and the same count. Renaming a method nothing has been paid with is still free, and so is every other column at any time.
+     *
+     * @param {string} id - The payment method configuration. A uuid — the data plane casts this segment and answers 400, not 404, for anything else.
+     * @param {string} code - The machine name of the method, unique per tenant and lower case by convention ('invoice', 'prepayment', 'card', 'paypal'). It is the string the checkout asks for, the string every payment stores, and therefore the one value here that cannot be changed freely: renaming it would leave the ledger naming something that no longer exists, so it is refused with 409 for as long as any payment names it. Required on create.
+     * @param {string[]} countries - Allowed ISO 3166-1 alpha-2 country codes, compared upper-cased against the buyer country. null or an empty list means unrestricted — the invoice method this app seeds is restricted to DE, which is why an eligibility call without a country sees it excluded.
+     * @param {string} description - One line explaining the method where it is offered — payment terms, what happens after the order. Shown to the buyer, so it is the merchant's wording rather than the app's.
+     * @param {boolean} enabled - A disabled method is never eligible and never reaches a checkout. This is the switch an operator wants: deleting a method the ledger still names — or renaming its `code` — is refused with 409. Defaults to false, so a half-configured method cannot reach a checkout by accident.
+     * @param {number} feeAmount - The surcharge this method costs the buyer, read as an amount or as a percentage depending on `fee_type`. Never negative — a discount for paying a certain way is not expressible here. Defaults to 0.
+     * @param {string} feeCurrency - ISO 4217 code a fixed fee is expressed in. The database bounds the length at three characters and nothing else, so lower case is stored as written. Defaults to EUR, and lower case is accepted here exactly as the handlers accept it.
+     * @param {PaymentFeeType} feeType - How `fee_amount` applies: 'none' (no surcharge), 'fixed' (that many units of `fee_currency`) or 'percent' (that share of the order amount). Defaults to 'none'.
+     * @param {PaymentMethodKind} kind - Who moves the money. 'self_managed' — invoice, prepayment — means the merchant fulfils and reconciles it outside any PSP, and such a payment authorizes the moment it is created. 'psp' means a configured provider authorizes, captures and refunds it. Defaults to 'self_managed'; 'psp' needs a 'provider' to transact.
+     * @param {object} labels - Buyer-facing names keyed by language tag — what a storefront shows instead of the operator-facing `name`. Free jsonb: the database constrains neither the tags nor the values, so a client reads the tag it wants and falls back to `en`.
+     * @param {number} maxOrderValue - Largest order amount this method may be used for — the usual credit-risk cap on invoice and prepayment. null means no upper bound.
+     * @param {object} metadata - Free-form merchant data carried on the configuration. This app never reads it — it is storage for the integrations that do (an ERP key for the method, a ledger account, a display hint).
+     * @param {number} minOrderValue - Smallest order amount this method may be used for — the usual guard against paying a €5 order by invoice. null means no lower bound.
+     * @param {string} name - Operator-facing name, in the language the merchant administers in. What a buyer sees comes from `labels`. Required on create.
+     * @param {number} position - Sort order at checkout, ascending — the merchant's preferred payment method first. Defaults to 0.
+     * @param {string} provider - The PSP code this method transacts through, from GET /payments/providers/catalog. Only meaningful for kind 'psp'; a PSP method that names none falls back to the tenant's `default_provider` setting. Must be a code GET /payments/providers/catalog carries.
+     * @param {string} providerMethod - The provider's own payment-method id ('card', 'paypal', 'sepa_debit') — what the driver is told to charge. Copied onto every payment created with this method as `metadata.provider_method`.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    paymentsMethodsUpdate(id: string, code?: string, countries?: string[], description?: string, enabled?: boolean, feeAmount?: number, feeCurrency?: string, feeType?: PaymentFeeType, kind?: PaymentMethodKind, labels?: object, maxOrderValue?: number, metadata?: object, minOrderValue?: number, name?: string, position?: number, provider?: string, providerMethod?: string): Promise<Models.Error>;
+}
+
+export { PaymentsMethods };