@randock/nameshift-api-client 0.0.497 → 0.0.499

package/src/apis/AdminApi.ts

@@ -67,7 +67,9 @@ import type {
   ListLeads200Response,
   NotFoundException,
   ObjectId,
+  PaySellerInvoicesInput,
   SellerLeadDetails,
+  SellerPayoutPreviewDto,
   SellerSalesByTldStatsItemDto,
   SellerSalesCountStatsItemDto,
   SendAdminLeadAiPriceNegotiatorAgentChatMessageInput,
@@ -189,8 +191,12 @@ import {
     NotFoundExceptionToJSON,
     ObjectIdFromJSON,
     ObjectIdToJSON,
+    PaySellerInvoicesInputFromJSON,
+    PaySellerInvoicesInputToJSON,
     SellerLeadDetailsFromJSON,
     SellerLeadDetailsToJSON,
+    SellerPayoutPreviewDtoFromJSON,
+    SellerPayoutPreviewDtoToJSON,
     SellerSalesByTldStatsItemDtoFromJSON,
     SellerSalesByTldStatsItemDtoToJSON,
     SellerSalesCountStatsItemDtoFromJSON,
@@ -541,13 +547,12 @@ export interface AdminApiLoginAsBuyerRequest {
     buyerId: string;
 }
 
-export interface AdminApiPayDomainTransferSellerInvoiceRequest {
-    transferId: string;
+export interface AdminApiPaySellerInvoiceRequest {
     invoiceId: string;
 }
 
-export interface AdminApiPaySellerInvoiceRequest {
-    invoiceId: string;
+export interface AdminApiPaySellerInvoicesRequest {
+    paySellerInvoicesInput: PaySellerInvoicesInput;
 }
 
 export interface AdminApiPostAdminCompleteDomainTransferRequest {
@@ -564,6 +569,10 @@ export interface AdminApiPostAiPriceNegotiatorAgentChatMessageRequest {
     sendAdminLeadAiPriceNegotiatorAgentChatMessageInput: SendAdminLeadAiPriceNegotiatorAgentChatMessageInput;
 }
 
+export interface AdminApiPreviewSellerPayoutRequest {
+    paySellerInvoicesInput: PaySellerInvoicesInput;
+}
+
 export interface AdminApiPurgeDomainCdnCacheRequest {
     domainId: string;
 }
@@ -3588,21 +3597,14 @@ export class AdminApi extends runtime.BaseAPI {
     }
 
     /**
-     * Processes payment of a seller invoice associated with a domain transfer.
-     * Pay domain transfer seller invoice
+     * Marks a seller invoice transaction as paid when the payout has been processed.
+     * Pay seller invoice
      */
-    async payDomainTransferSellerInvoiceRaw(requestParameters: AdminApiPayDomainTransferSellerInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters['transferId'] == null) {
-            throw new runtime.RequiredError(
-                'transferId',
-                'Required parameter "transferId" was null or undefined when calling payDomainTransferSellerInvoice().'
-            );
-        }
-
+    async paySellerInvoiceRaw(requestParameters: AdminApiPaySellerInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         if (requestParameters['invoiceId'] == null) {
             throw new runtime.RequiredError(
                 'invoiceId',
-                'Required parameter "invoiceId" was null or undefined when calling payDomainTransferSellerInvoice().'
+                'Required parameter "invoiceId" was null or undefined when calling paySellerInvoice().'
             );
         }
 
@@ -3619,7 +3621,7 @@ export class AdminApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/admin/domain-transfers/{transferId}/seller-invoices/{invoiceId}/pay`.replace(`{${"transferId"}}`, encodeURIComponent(String(requestParameters['transferId']))).replace(`{${"invoiceId"}}`, encodeURIComponent(String(requestParameters['invoiceId']))),
+            path: `/admin/invoices/{invoiceId}/pay`.replace(`{${"invoiceId"}}`, encodeURIComponent(String(requestParameters['invoiceId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
@@ -3629,22 +3631,22 @@ export class AdminApi extends runtime.BaseAPI {
     }
 
     /**
-     * Processes payment of a seller invoice associated with a domain transfer.
-     * Pay domain transfer seller invoice
+     * Marks a seller invoice transaction as paid when the payout has been processed.
+     * Pay seller invoice
      */
-    async payDomainTransferSellerInvoice(requestParameters: AdminApiPayDomainTransferSellerInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.payDomainTransferSellerInvoiceRaw(requestParameters, initOverrides);
+    async paySellerInvoice(requestParameters: AdminApiPaySellerInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.paySellerInvoiceRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Marks a seller invoice transaction as paid when the payout has been processed.
-     * Pay seller invoice
+     * Pays several invoices of one seller out together. To a bank account they go in one transfer, so the seller pays the fee of an international transfer once; they then have to be in one currency. Through Stripe each invoice is its own transfer.
+     * Pay seller invoices in one payout
      */
-    async paySellerInvoiceRaw(requestParameters: AdminApiPaySellerInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters['invoiceId'] == null) {
+    async paySellerInvoicesRaw(requestParameters: AdminApiPaySellerInvoicesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['paySellerInvoicesInput'] == null) {
             throw new runtime.RequiredError(
-                'invoiceId',
-                'Required parameter "invoiceId" was null or undefined when calling paySellerInvoice().'
+                'paySellerInvoicesInput',
+                'Required parameter "paySellerInvoicesInput" was null or undefined when calling paySellerInvoices().'
             );
         }
 
@@ -3652,6 +3654,8 @@ export class AdminApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -3661,21 +3665,22 @@ export class AdminApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/admin/invoices/{invoiceId}/pay`.replace(`{${"invoiceId"}}`, encodeURIComponent(String(requestParameters['invoiceId']))),
+            path: `/admin/invoices/pay`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: PaySellerInvoicesInputToJSON(requestParameters['paySellerInvoicesInput']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Marks a seller invoice transaction as paid when the payout has been processed.
-     * Pay seller invoice
+     * Pays several invoices of one seller out together. To a bank account they go in one transfer, so the seller pays the fee of an international transfer once; they then have to be in one currency. Through Stripe each invoice is its own transfer.
+     * Pay seller invoices in one payout
      */
-    async paySellerInvoice(requestParameters: AdminApiPaySellerInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.paySellerInvoiceRaw(requestParameters, initOverrides);
+    async paySellerInvoices(requestParameters: AdminApiPaySellerInvoicesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.paySellerInvoicesRaw(requestParameters, initOverrides);
     }
 
     /**
@@ -3822,6 +3827,52 @@ export class AdminApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Tells what paying these invoices out together would do, without doing it: the bank account the transfer goes to, and the fee taken out of what the seller receives. Refuses what paying them would refuse.
+     * Preview a payout of seller invoices
+     */
+    async previewSellerPayoutRaw(requestParameters: AdminApiPreviewSellerPayoutRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SellerPayoutPreviewDto>> {
+        if (requestParameters['paySellerInvoicesInput'] == null) {
+            throw new runtime.RequiredError(
+                'paySellerInvoicesInput',
+                'Required parameter "paySellerInvoicesInput" was null or undefined when calling previewSellerPayout().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/admin/invoices/pay/preview`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PaySellerInvoicesInputToJSON(requestParameters['paySellerInvoicesInput']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SellerPayoutPreviewDtoFromJSON(jsonValue));
+    }
+
+    /**
+     * Tells what paying these invoices out together would do, without doing it: the bank account the transfer goes to, and the fee taken out of what the seller receives. Refuses what paying them would refuse.
+     * Preview a payout of seller invoices
+     */
+    async previewSellerPayout(requestParameters: AdminApiPreviewSellerPayoutRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SellerPayoutPreviewDto> {
+        const response = await this.previewSellerPayoutRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Purges the CDN cache for the specified domain landing page.
      * Purge domain CDN cache

package/src/models/AccountBankAccountDto.ts

@@ -13,6 +13,13 @@
  */
 
 import { mapValues } from '../runtime';
+import type { MoneyDto } from './MoneyDto';
+import {
+    MoneyDtoFromJSON,
+    MoneyDtoFromJSONTyped,
+    MoneyDtoToJSON,
+    MoneyDtoToJSONTyped,
+} from './MoneyDto';
 import type { AccountBankAccountDetailsDto } from './AccountBankAccountDetailsDto';
 import {
     AccountBankAccountDetailsDtoFromJSON,
@@ -75,6 +82,18 @@ export interface AccountBankAccountDto {
      * @memberof AccountBankAccountDto
      */
     payable: boolean;
+    /**
+     * How we pay out to this bank account: LOCAL over the country's own clearing system, which costs the seller nothing, or SWIFT, an international transfer whose fee is taken out of each payout. Null when we can't pay out to it.
+     * @type {string}
+     * @memberof AccountBankAccountDto
+     */
+    transferMethod: AccountBankAccountDtoTransferMethodEnum | null;
+    /**
+     * What a payout to this bank account costs the seller, as an indication: the fee of a SWIFT transfer in the account currency at the rate of the day. Null for a local payout, and when the fee is not known.
+     * @type {MoneyDto}
+     * @memberof AccountBankAccountDto
+     */
+    payoutFee: MoneyDto | null;
 }
 
 
@@ -100,6 +119,15 @@ export const AccountBankAccountDtoNameCheckStatusEnum = {
 } as const;
 export type AccountBankAccountDtoNameCheckStatusEnum = typeof AccountBankAccountDtoNameCheckStatusEnum[keyof typeof AccountBankAccountDtoNameCheckStatusEnum];
 
+/**
+ * @export
+ */
+export const AccountBankAccountDtoTransferMethodEnum = {
+    LOCAL: 'LOCAL',
+    SWIFT: 'SWIFT'
+} as const;
+export type AccountBankAccountDtoTransferMethodEnum = typeof AccountBankAccountDtoTransferMethodEnum[keyof typeof AccountBankAccountDtoTransferMethodEnum];
+
 
 /**
  * Check if a given object implements the AccountBankAccountDto interface.
@@ -113,6 +141,8 @@ export function instanceOfAccountBankAccountDto(value: object): value is Account
     if (!('bankStatementSubmittedAt' in value) || value['bankStatementSubmittedAt'] === undefined) return false;
     if (!('details' in value) || value['details'] === undefined) return false;
     if (!('payable' in value) || value['payable'] === undefined) return false;
+    if (!('transferMethod' in value) || value['transferMethod'] === undefined) return false;
+    if (!('payoutFee' in value) || value['payoutFee'] === undefined) return false;
     return true;
 }
 
@@ -134,6 +164,8 @@ export function AccountBankAccountDtoFromJSONTyped(json: any, ignoreDiscriminato
         'bankStatementSubmittedAt': (json['bankStatementSubmittedAt'] == null ? null : new Date(json['bankStatementSubmittedAt'])),
         'details': AccountBankAccountDetailsDtoFromJSON(json['details']),
         'payable': json['payable'],
+        'transferMethod': json['transferMethod'],
+        'payoutFee': MoneyDtoFromJSON(json['payoutFee']),
     };
 }
 
@@ -156,6 +188,8 @@ export function AccountBankAccountDtoToJSONTyped(value?: AccountBankAccountDto |
         'bankStatementSubmittedAt': (value['bankStatementSubmittedAt'] == null ? null : (value['bankStatementSubmittedAt'] as any).toISOString()),
         'details': AccountBankAccountDetailsDtoToJSON(value['details']),
         'payable': value['payable'],
+        'transferMethod': value['transferMethod'],
+        'payoutFee': MoneyDtoToJSON(value['payoutFee']),
     };
 }
 

package/src/models/AccountPayoutDto.ts

@@ -13,6 +13,14 @@
  */
 
 import { mapValues } from '../runtime';
+import type { PayoutFrequency } from './PayoutFrequency';
+import {
+    PayoutFrequencyFromJSON,
+    PayoutFrequencyFromJSONTyped,
+    PayoutFrequencyToJSON,
+    PayoutFrequencyToJSONTyped,
+} from './PayoutFrequency';
+
 /**
  * 
  * @export
@@ -31,6 +39,18 @@ export interface AccountPayoutDto {
      * @memberof AccountPayoutDto
      */
     provider: AccountPayoutDtoProviderEnum;
+    /**
+     * How often the seller is paid out when they are paid out automatically: each invoice as soon as it can be (immediate), or what came in during a week, two weeks, month or quarter when the next one starts. An admin pays out the others, whatever this says.
+     * @type {PayoutFrequency}
+     * @memberof AccountPayoutDto
+     */
+    frequency: PayoutFrequency;
+    /**
+     * Whether payouts that cost the seller nothing (a local transfer to their bank account) wait for the frequency too. When false, those are made as soon as they can be, and only payouts with a transfer fee wait, to go out together.
+     * @type {boolean}
+     * @memberof AccountPayoutDto
+     */
+    batchFreePayouts: boolean;
 }
 
 
@@ -50,6 +70,8 @@ export type AccountPayoutDtoProviderEnum = typeof AccountPayoutDtoProviderEnum[k
 export function instanceOfAccountPayoutDto(value: object): value is AccountPayoutDto {
     if (!('automatic' in value) || value['automatic'] === undefined) return false;
     if (!('provider' in value) || value['provider'] === undefined) return false;
+    if (!('frequency' in value) || value['frequency'] === undefined) return false;
+    if (!('batchFreePayouts' in value) || value['batchFreePayouts'] === undefined) return false;
     return true;
 }
 
@@ -65,6 +87,8 @@ export function AccountPayoutDtoFromJSONTyped(json: any, ignoreDiscriminator: bo
         
         'automatic': json['automatic'],
         'provider': json['provider'],
+        'frequency': PayoutFrequencyFromJSON(json['frequency']),
+        'batchFreePayouts': json['batchFreePayouts'],
     };
 }
 
@@ -81,6 +105,8 @@ export function AccountPayoutDtoToJSONTyped(value?: AccountPayoutDto | null, ign
         
         'automatic': value['automatic'],
         'provider': value['provider'],
+        'frequency': PayoutFrequencyToJSON(value['frequency']),
+        'batchFreePayouts': value['batchFreePayouts'],
     };
 }
 

package/src/models/BankAccountFormatCountryDto.ts

@@ -26,11 +26,17 @@ export interface BankAccountFormatCountryDto {
      */
     countryCode: string;
     /**
-     * ISO 4217 codes of the currencies we pay out to in this country, the country's own currency first.
+     * ISO 4217 codes of the currencies we pay out to in this country: first the ones paid out locally, the country's own currency ahead, then the ones in `swiftCurrencyCodes`.
      * @type {Array<string>}
      * @memberof BankAccountFormatCountryDto
      */
     currencyCodes: Array<string>;
+    /**
+     * The currencies among `currencyCodes` that are paid out by SWIFT, an international transfer with a fee per payout, because there is no local payout for them in this country.
+     * @type {Array<string>}
+     * @memberof BankAccountFormatCountryDto
+     */
+    swiftCurrencyCodes: Array<string>;
 }
 
 /**
@@ -39,6 +45,7 @@ export interface BankAccountFormatCountryDto {
 export function instanceOfBankAccountFormatCountryDto(value: object): value is BankAccountFormatCountryDto {
     if (!('countryCode' in value) || value['countryCode'] === undefined) return false;
     if (!('currencyCodes' in value) || value['currencyCodes'] === undefined) return false;
+    if (!('swiftCurrencyCodes' in value) || value['swiftCurrencyCodes'] === undefined) return false;
     return true;
 }
 
@@ -54,6 +61,7 @@ export function BankAccountFormatCountryDtoFromJSONTyped(json: any, ignoreDiscri
         
         'countryCode': json['countryCode'],
         'currencyCodes': json['currencyCodes'],
+        'swiftCurrencyCodes': json['swiftCurrencyCodes'],
     };
 }
 
@@ -70,6 +78,7 @@ export function BankAccountFormatCountryDtoToJSONTyped(value?: BankAccountFormat
         
         'countryCode': value['countryCode'],
         'currencyCodes': value['currencyCodes'],
+        'swiftCurrencyCodes': value['swiftCurrencyCodes'],
     };
 }
 

package/src/models/BankAccountFormatDto.ts

@@ -20,6 +20,20 @@ import {
     BankAccountFormatFieldDtoToJSON,
     BankAccountFormatFieldDtoToJSONTyped,
 } from './BankAccountFormatFieldDto';
+import type { MoneyDto } from './MoneyDto';
+import {
+    MoneyDtoFromJSON,
+    MoneyDtoFromJSONTyped,
+    MoneyDtoToJSON,
+    MoneyDtoToJSONTyped,
+} from './MoneyDto';
+import type { BankAccountTransferMethod } from './BankAccountTransferMethod';
+import {
+    BankAccountTransferMethodFromJSON,
+    BankAccountTransferMethodFromJSONTyped,
+    BankAccountTransferMethodToJSON,
+    BankAccountTransferMethodToJSONTyped,
+} from './BankAccountTransferMethod';
 
 /**
  * 
@@ -39,6 +53,18 @@ export interface BankAccountFormatDto {
      * @memberof BankAccountFormatDto
      */
     currencyCode: string;
+    /**
+     * How we pay out to such an account: LOCAL over the country's own clearing system, which costs the seller nothing, or SWIFT, an international transfer whose fee is taken out of each payout.
+     * @type {BankAccountTransferMethod}
+     * @memberof BankAccountFormatDto
+     */
+    transferMethod: BankAccountTransferMethod;
+    /**
+     * What a payout to such an account costs the seller, as an indication: the fee of a SWIFT transfer in the account currency at the rate of the day. Null for a local payout, and when the fee is not known.
+     * @type {MoneyDto}
+     * @memberof BankAccountFormatDto
+     */
+    payoutFee: MoneyDto | null;
     /**
      * The fields to fill in, in display order.
      * @type {Array<BankAccountFormatFieldDto>}
@@ -47,12 +73,16 @@ export interface BankAccountFormatDto {
     fields: Array<BankAccountFormatFieldDto>;
 }
 
+
+
 /**
  * Check if a given object implements the BankAccountFormatDto interface.
  */
 export function instanceOfBankAccountFormatDto(value: object): value is BankAccountFormatDto {
     if (!('countryCode' in value) || value['countryCode'] === undefined) return false;
     if (!('currencyCode' in value) || value['currencyCode'] === undefined) return false;
+    if (!('transferMethod' in value) || value['transferMethod'] === undefined) return false;
+    if (!('payoutFee' in value) || value['payoutFee'] === undefined) return false;
     if (!('fields' in value) || value['fields'] === undefined) return false;
     return true;
 }
@@ -69,6 +99,8 @@ export function BankAccountFormatDtoFromJSONTyped(json: any, ignoreDiscriminator
         
         'countryCode': json['countryCode'],
         'currencyCode': json['currencyCode'],
+        'transferMethod': BankAccountTransferMethodFromJSON(json['transferMethod']),
+        'payoutFee': MoneyDtoFromJSON(json['payoutFee']),
         'fields': ((json['fields'] as Array<any>).map(BankAccountFormatFieldDtoFromJSON)),
     };
 }
@@ -86,6 +118,8 @@ export function BankAccountFormatDtoToJSONTyped(value?: BankAccountFormatDto | n
         
         'countryCode': value['countryCode'],
         'currencyCode': value['currencyCode'],
+        'transferMethod': BankAccountTransferMethodToJSON(value['transferMethod']),
+        'payoutFee': MoneyDtoToJSON(value['payoutFee']),
         'fields': ((value['fields'] as Array<any>).map(BankAccountFormatFieldDtoToJSON)),
     };
 }

package/src/models/BankAccountTransferMethod.ts

@@ -0,0 +1,53 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Nameshift
+ * Nameshift domain marketplace and management API.  ## Authentication - **Bearer JWT** — Seller and buyer sessions obtained via login endpoints. - **API key** — Pass the `apikey` header for programmatic seller access.  ## Audiences - **(public)** tags — Unauthenticated or buyer-facing endpoints. - **Accounts / Domains / Leads / Buyers** — Seller or buyer resources. - **Partner** — Partner integrations.
+ *
+ * The version of the OpenAPI document: 1.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+/**
+ * How the payout reaches the bank account: LOCAL over the country's own clearing system, or SWIFT, an international transfer with a fee.
+ * @export
+ */
+export const BankAccountTransferMethod = {
+    LOCAL: 'LOCAL',
+    SWIFT: 'SWIFT'
+} as const;
+export type BankAccountTransferMethod = typeof BankAccountTransferMethod[keyof typeof BankAccountTransferMethod];
+
+
+export function instanceOfBankAccountTransferMethod(value: any): boolean {
+    for (const key in BankAccountTransferMethod) {
+        if (Object.prototype.hasOwnProperty.call(BankAccountTransferMethod, key)) {
+            if (BankAccountTransferMethod[key as keyof typeof BankAccountTransferMethod] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+export function BankAccountTransferMethodFromJSON(json: any): BankAccountTransferMethod {
+    return BankAccountTransferMethodFromJSONTyped(json, false);
+}
+
+export function BankAccountTransferMethodFromJSONTyped(json: any, ignoreDiscriminator: boolean): BankAccountTransferMethod {
+    return json as BankAccountTransferMethod;
+}
+
+export function BankAccountTransferMethodToJSON(value?: BankAccountTransferMethod | null): any {
+    return value as any;
+}
+
+export function BankAccountTransferMethodToJSONTyped(value: any, ignoreDiscriminator: boolean): BankAccountTransferMethod {
+    return value as BankAccountTransferMethod;
+}
+

package/src/models/InvoiceDto.ts

@@ -27,6 +27,13 @@ import {
     InvoiceSellerAccountDtoToJSON,
     InvoiceSellerAccountDtoToJSONTyped,
 } from './InvoiceSellerAccountDto';
+import type { InvoicePayoutDto } from './InvoicePayoutDto';
+import {
+    InvoicePayoutDtoFromJSON,
+    InvoicePayoutDtoFromJSONTyped,
+    InvoicePayoutDtoToJSON,
+    InvoicePayoutDtoToJSONTyped,
+} from './InvoicePayoutDto';
 import type { MoneyDto } from './MoneyDto';
 import {
     MoneyDtoFromJSON,
@@ -126,6 +133,18 @@ export interface InvoiceDto {
      * @memberof InvoiceDto
      */
     transaction: InvoiceDtoTransaction | null;
+    /**
+     * For a seller invoice awaiting its payout: when it is due, by how often the seller wants to be paid out. A payout that costs the seller nothing is due right away, unless they want those to wait too, and so is every invoice of a seller who is not paid out automatically. Null when it awaits no payout.
+     * @type {Date}
+     * @memberof InvoiceDto
+     */
+    payoutDueAt: Date | null;
+    /**
+     * The bank transfer a seller invoice is or was last paid out with. Null when it was in none.
+     * @type {InvoicePayoutDto}
+     * @memberof InvoiceDto
+     */
+    payout: InvoicePayoutDto | null;
 }
 
 
@@ -167,6 +186,8 @@ export function instanceOfInvoiceDto(value: object): value is InvoiceDto {
     if (!('isAffiliateCommission' in value) || value['isAffiliateCommission'] === undefined) return false;
     if (!('buyerEmail' in value) || value['buyerEmail'] === undefined) return false;
     if (!('transaction' in value) || value['transaction'] === undefined) return false;
+    if (!('payoutDueAt' in value) || value['payoutDueAt'] === undefined) return false;
+    if (!('payout' in value) || value['payout'] === undefined) return false;
     return true;
 }
 
@@ -193,6 +214,8 @@ export function InvoiceDtoFromJSONTyped(json: any, ignoreDiscriminator: boolean)
         'isAffiliateCommission': json['isAffiliateCommission'],
         'buyerEmail': json['buyerEmail'],
         'transaction': InvoiceDtoTransactionFromJSON(json['transaction']),
+        'payoutDueAt': (json['payoutDueAt'] == null ? null : new Date(json['payoutDueAt'])),
+        'payout': InvoicePayoutDtoFromJSON(json['payout']),
     };
 }
 
@@ -220,6 +243,8 @@ export function InvoiceDtoToJSONTyped(value?: InvoiceDto | null, ignoreDiscrimin
         'isAffiliateCommission': value['isAffiliateCommission'],
         'buyerEmail': value['buyerEmail'],
         'transaction': InvoiceDtoTransactionToJSON(value['transaction']),
+        'payoutDueAt': (value['payoutDueAt'] == null ? null : (value['payoutDueAt'] as any).toISOString()),
+        'payout': InvoicePayoutDtoToJSON(value['payout']),
     };
 }