@randock/nameshift-api-client 0.0.354 → 0.0.355

package/src/apis/AccountsApi.ts

@@ -16,13 +16,19 @@
 import * as runtime from '../runtime';
 import type {
   AccountOnboardingSessionDto,
+  AccountPaymentDto,
+  AccountPaymentMethodDto,
   AccountSettingsDto,
   AccountSettingsInput,
   BadRequestException,
+  CreateAccountPaymentInput,
+  CreateAccountPaymentManualTransactionInput,
   GetAllAffiliateCommissions200Response,
   GetAllReferrals200Response,
   MoneyDto,
   NotFoundException,
+  ObjectId,
+  PayAccountPaymentInput,
   PrivateAccountGetMeResponse,
   SetPayoutProviderInput,
   UpdateAccountBillingInformationInput,
@@ -31,12 +37,20 @@ import type {
 import {
     AccountOnboardingSessionDtoFromJSON,
     AccountOnboardingSessionDtoToJSON,
+    AccountPaymentDtoFromJSON,
+    AccountPaymentDtoToJSON,
+    AccountPaymentMethodDtoFromJSON,
+    AccountPaymentMethodDtoToJSON,
     AccountSettingsDtoFromJSON,
     AccountSettingsDtoToJSON,
     AccountSettingsInputFromJSON,
     AccountSettingsInputToJSON,
     BadRequestExceptionFromJSON,
     BadRequestExceptionToJSON,
+    CreateAccountPaymentInputFromJSON,
+    CreateAccountPaymentInputToJSON,
+    CreateAccountPaymentManualTransactionInputFromJSON,
+    CreateAccountPaymentManualTransactionInputToJSON,
     GetAllAffiliateCommissions200ResponseFromJSON,
     GetAllAffiliateCommissions200ResponseToJSON,
     GetAllReferrals200ResponseFromJSON,
@@ -45,6 +59,10 @@ import {
     MoneyDtoToJSON,
     NotFoundExceptionFromJSON,
     NotFoundExceptionToJSON,
+    ObjectIdFromJSON,
+    ObjectIdToJSON,
+    PayAccountPaymentInputFromJSON,
+    PayAccountPaymentInputToJSON,
     PrivateAccountGetMeResponseFromJSON,
     PrivateAccountGetMeResponseToJSON,
     SetPayoutProviderInputFromJSON,
@@ -55,6 +73,27 @@ import {
     ValidationExceptionToJSON,
 } from '../models/index';
 
+export interface AccountsApiCreateAccountPaymentRequest {
+    accountId: string;
+    createAccountPaymentInput: CreateAccountPaymentInput;
+}
+
+export interface AccountsApiCreateAccountPaymentManualTransactionRequest {
+    accountId: string;
+    paymentId: string;
+    createAccountPaymentManualTransactionInput: CreateAccountPaymentManualTransactionInput;
+}
+
+export interface AccountsApiGetAccountPaymentRequest {
+    accountId: string;
+    paymentId: string;
+}
+
+export interface AccountsApiGetAccountPaymentMethodsRequest {
+    accountId: string;
+    gateway: GetAccountPaymentMethodsGatewayEnum;
+}
+
 export interface AccountsApiGetAccountPaymentProviderSessionRequest {
     accountId: string;
 }
@@ -79,6 +118,12 @@ export interface AccountsApiGetAllReferralsRequest {
     sortBy?: Array<string>;
 }
 
+export interface AccountsApiPayAccountPaymentRequest {
+    accountId: string;
+    paymentId: string;
+    payAccountPaymentInput: PayAccountPaymentInput;
+}
+
 export interface AccountsApiPostBillingInformationRequest {
     accountId: string;
     updateAccountBillingInformationInput: UpdateAccountBillingInformationInput;
@@ -109,6 +154,116 @@ export interface AccountsApiUpdateSettingsRequest {
  */
 export class AccountsApi extends runtime.BaseAPI {
 
+    /**
+     * 
+     */
+    async createAccountPaymentRaw(requestParameters: AccountsApiCreateAccountPaymentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ObjectId>> {
+        if (requestParameters['accountId'] == null) {
+            throw new runtime.RequiredError(
+                'accountId',
+                'Required parameter "accountId" was null or undefined when calling createAccountPayment().'
+            );
+        }
+
+        if (requestParameters['createAccountPaymentInput'] == null) {
+            throw new runtime.RequiredError(
+                'createAccountPaymentInput',
+                'Required parameter "createAccountPaymentInput" was null or undefined when calling createAccountPayment().'
+            );
+        }
+
+        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: `/private/accounts/{accountId}/payments`.replace(`{${"accountId"}}`, encodeURIComponent(String(requestParameters['accountId']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateAccountPaymentInputToJSON(requestParameters['createAccountPaymentInput']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ObjectIdFromJSON(jsonValue));
+    }
+
+    /**
+     * 
+     */
+    async createAccountPayment(requestParameters: AccountsApiCreateAccountPaymentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ObjectId> {
+        const response = await this.createAccountPaymentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates a new manual transaction for account payment with specified open invoice
+     * Create a new manual transaction for account payment invoice
+     */
+    async createAccountPaymentManualTransactionRaw(requestParameters: AccountsApiCreateAccountPaymentManualTransactionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['accountId'] == null) {
+            throw new runtime.RequiredError(
+                'accountId',
+                'Required parameter "accountId" was null or undefined when calling createAccountPaymentManualTransaction().'
+            );
+        }
+
+        if (requestParameters['paymentId'] == null) {
+            throw new runtime.RequiredError(
+                'paymentId',
+                'Required parameter "paymentId" was null or undefined when calling createAccountPaymentManualTransaction().'
+            );
+        }
+
+        if (requestParameters['createAccountPaymentManualTransactionInput'] == null) {
+            throw new runtime.RequiredError(
+                'createAccountPaymentManualTransactionInput',
+                'Required parameter "createAccountPaymentManualTransactionInput" was null or undefined when calling createAccountPaymentManualTransaction().'
+            );
+        }
+
+        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: `/private/accounts/{accountId}/payments/{paymentId}/transactions`.replace(`{${"accountId"}}`, encodeURIComponent(String(requestParameters['accountId']))).replace(`{${"paymentId"}}`, encodeURIComponent(String(requestParameters['paymentId']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateAccountPaymentManualTransactionInputToJSON(requestParameters['createAccountPaymentManualTransactionInput']),
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Creates a new manual transaction for account payment with specified open invoice
+     * Create a new manual transaction for account payment invoice
+     */
+    async createAccountPaymentManualTransaction(requestParameters: AccountsApiCreateAccountPaymentManualTransactionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.createAccountPaymentManualTransactionRaw(requestParameters, initOverrides);
+    }
+
     /**
      * 
      */
@@ -142,6 +297,102 @@ export class AccountsApi extends runtime.BaseAPI {
         await this.deleteMeRaw(initOverrides);
     }
 
+    /**
+     * 
+     */
+    async getAccountPaymentRaw(requestParameters: AccountsApiGetAccountPaymentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccountPaymentDto>> {
+        if (requestParameters['accountId'] == null) {
+            throw new runtime.RequiredError(
+                'accountId',
+                'Required parameter "accountId" was null or undefined when calling getAccountPayment().'
+            );
+        }
+
+        if (requestParameters['paymentId'] == null) {
+            throw new runtime.RequiredError(
+                'paymentId',
+                'Required parameter "paymentId" was null or undefined when calling getAccountPayment().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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: `/private/accounts/{accountId}/payments/{paymentId}`.replace(`{${"accountId"}}`, encodeURIComponent(String(requestParameters['accountId']))).replace(`{${"paymentId"}}`, encodeURIComponent(String(requestParameters['paymentId']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => AccountPaymentDtoFromJSON(jsonValue));
+    }
+
+    /**
+     * 
+     */
+    async getAccountPayment(requestParameters: AccountsApiGetAccountPaymentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountPaymentDto> {
+        const response = await this.getAccountPaymentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * 
+     */
+    async getAccountPaymentMethodsRaw(requestParameters: AccountsApiGetAccountPaymentMethodsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<AccountPaymentMethodDto>>> {
+        if (requestParameters['accountId'] == null) {
+            throw new runtime.RequiredError(
+                'accountId',
+                'Required parameter "accountId" was null or undefined when calling getAccountPaymentMethods().'
+            );
+        }
+
+        if (requestParameters['gateway'] == null) {
+            throw new runtime.RequiredError(
+                'gateway',
+                'Required parameter "gateway" was null or undefined when calling getAccountPaymentMethods().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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: `/private/accounts/{accountId}/payment-methods/{gateway}`.replace(`{${"accountId"}}`, encodeURIComponent(String(requestParameters['accountId']))).replace(`{${"gateway"}}`, encodeURIComponent(String(requestParameters['gateway']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AccountPaymentMethodDtoFromJSON));
+    }
+
+    /**
+     * 
+     */
+    async getAccountPaymentMethods(requestParameters: AccountsApiGetAccountPaymentMethodsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<AccountPaymentMethodDto>> {
+        const response = await this.getAccountPaymentMethodsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * 
      */
@@ -406,6 +657,65 @@ export class AccountsApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Pays an account payment by confirming the payment intent using the specified payment method
+     * Pay an account payment
+     */
+    async payAccountPaymentRaw(requestParameters: AccountsApiPayAccountPaymentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['accountId'] == null) {
+            throw new runtime.RequiredError(
+                'accountId',
+                'Required parameter "accountId" was null or undefined when calling payAccountPayment().'
+            );
+        }
+
+        if (requestParameters['paymentId'] == null) {
+            throw new runtime.RequiredError(
+                'paymentId',
+                'Required parameter "paymentId" was null or undefined when calling payAccountPayment().'
+            );
+        }
+
+        if (requestParameters['payAccountPaymentInput'] == null) {
+            throw new runtime.RequiredError(
+                'payAccountPaymentInput',
+                'Required parameter "payAccountPaymentInput" was null or undefined when calling payAccountPayment().'
+            );
+        }
+
+        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: `/private/accounts/{accountId}/payments/{paymentId}/pay`.replace(`{${"accountId"}}`, encodeURIComponent(String(requestParameters['accountId']))).replace(`{${"paymentId"}}`, encodeURIComponent(String(requestParameters['paymentId']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PayAccountPaymentInputToJSON(requestParameters['payAccountPaymentInput']),
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Pays an account payment by confirming the payment intent using the specified payment method
+     * Pay an account payment
+     */
+    async payAccountPayment(requestParameters: AccountsApiPayAccountPaymentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.payAccountPaymentRaw(requestParameters, initOverrides);
+    }
+
     /**
      * 
      */
@@ -665,3 +975,12 @@ export class AccountsApi extends runtime.BaseAPI {
     }
 
 }
+
+/**
+ * @export
+ */
+export const GetAccountPaymentMethodsGatewayEnum = {
+    STRIPE: 'stripe',
+    NICKY: 'nicky'
+} as const;
+export type GetAccountPaymentMethodsGatewayEnum = typeof GetAccountPaymentMethodsGatewayEnum[keyof typeof GetAccountPaymentMethodsGatewayEnum];

package/src/models/AccountPaymentDto.ts

@@ -0,0 +1,189 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Nameshift
+ * Nameshift API
+ *
+ * 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.
+ */
+
+import { mapValues } from '../runtime';
+import type { AccountPaymentMethodProfileDto } from './AccountPaymentMethodProfileDto';
+import {
+    AccountPaymentMethodProfileDtoFromJSON,
+    AccountPaymentMethodProfileDtoFromJSONTyped,
+    AccountPaymentMethodProfileDtoToJSON,
+    AccountPaymentMethodProfileDtoToJSONTyped,
+} from './AccountPaymentMethodProfileDto';
+import type { InvoiceItemDto } from './InvoiceItemDto';
+import {
+    InvoiceItemDtoFromJSON,
+    InvoiceItemDtoFromJSONTyped,
+    InvoiceItemDtoToJSON,
+    InvoiceItemDtoToJSONTyped,
+} from './InvoiceItemDto';
+import type { InvoiceTransactionDto } from './InvoiceTransactionDto';
+import {
+    InvoiceTransactionDtoFromJSON,
+    InvoiceTransactionDtoFromJSONTyped,
+    InvoiceTransactionDtoToJSON,
+    InvoiceTransactionDtoToJSONTyped,
+} from './InvoiceTransactionDto';
+import type { MoneyDto } from './MoneyDto';
+import {
+    MoneyDtoFromJSON,
+    MoneyDtoFromJSONTyped,
+    MoneyDtoToJSON,
+    MoneyDtoToJSONTyped,
+} from './MoneyDto';
+
+/**
+ * 
+ * @export
+ * @interface AccountPaymentDto
+ */
+export interface AccountPaymentDto {
+    /**
+     * The uuid for this account payment.
+     * @type {string}
+     * @memberof AccountPaymentDto
+     */
+    id: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof AccountPaymentDto
+     */
+    status: AccountPaymentDtoStatusEnum;
+    /**
+     * 
+     * @type {Array<AccountPaymentMethodProfileDto>}
+     * @memberof AccountPaymentDto
+     */
+    paymentMethodProfiles: Array<AccountPaymentMethodProfileDto>;
+    /**
+     * 
+     * @type {MoneyDto}
+     * @memberof AccountPaymentDto
+     */
+    basePrice: MoneyDto;
+    /**
+     * 
+     * @type {MoneyDto}
+     * @memberof AccountPaymentDto
+     */
+    totalPrice: MoneyDto;
+    /**
+     * 
+     * @type {MoneyDto}
+     * @memberof AccountPaymentDto
+     */
+    totalTaxPrice: MoneyDto;
+    /**
+     * 
+     * @type {Array<InvoiceItemDto>}
+     * @memberof AccountPaymentDto
+     */
+    items: Array<InvoiceItemDto>;
+    /**
+     * 
+     * @type {Array<string>}
+     * @memberof AccountPaymentDto
+     */
+    allowedPaymentMethods: Array<string>;
+    /**
+     * 
+     * @type {InvoiceTransactionDto}
+     * @memberof AccountPaymentDto
+     */
+    transaction: InvoiceTransactionDto;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof AccountPaymentDto
+     */
+    hasPendingTransaction: boolean;
+}
+
+
+/**
+ * @export
+ */
+export const AccountPaymentDtoStatusEnum = {
+    DRAFT: 'draft',
+    PENDING_PAYMENT: 'pending_payment',
+    PAID: 'paid',
+    CANCELLED: 'cancelled'
+} as const;
+export type AccountPaymentDtoStatusEnum = typeof AccountPaymentDtoStatusEnum[keyof typeof AccountPaymentDtoStatusEnum];
+
+
+/**
+ * Check if a given object implements the AccountPaymentDto interface.
+ */
+export function instanceOfAccountPaymentDto(value: object): value is AccountPaymentDto {
+    if (!('id' in value) || value['id'] === undefined) return false;
+    if (!('status' in value) || value['status'] === undefined) return false;
+    if (!('paymentMethodProfiles' in value) || value['paymentMethodProfiles'] === undefined) return false;
+    if (!('basePrice' in value) || value['basePrice'] === undefined) return false;
+    if (!('totalPrice' in value) || value['totalPrice'] === undefined) return false;
+    if (!('totalTaxPrice' in value) || value['totalTaxPrice'] === undefined) return false;
+    if (!('items' in value) || value['items'] === undefined) return false;
+    if (!('allowedPaymentMethods' in value) || value['allowedPaymentMethods'] === undefined) return false;
+    if (!('transaction' in value) || value['transaction'] === undefined) return false;
+    if (!('hasPendingTransaction' in value) || value['hasPendingTransaction'] === undefined) return false;
+    return true;
+}
+
+export function AccountPaymentDtoFromJSON(json: any): AccountPaymentDto {
+    return AccountPaymentDtoFromJSONTyped(json, false);
+}
+
+export function AccountPaymentDtoFromJSONTyped(json: any, ignoreDiscriminator: boolean): AccountPaymentDto {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'id': json['id'],
+        'status': json['status'],
+        'paymentMethodProfiles': ((json['paymentMethodProfiles'] as Array<any>).map(AccountPaymentMethodProfileDtoFromJSON)),
+        'basePrice': MoneyDtoFromJSON(json['basePrice']),
+        'totalPrice': MoneyDtoFromJSON(json['totalPrice']),
+        'totalTaxPrice': MoneyDtoFromJSON(json['totalTaxPrice']),
+        'items': ((json['items'] as Array<any>).map(InvoiceItemDtoFromJSON)),
+        'allowedPaymentMethods': json['allowedPaymentMethods'],
+        'transaction': InvoiceTransactionDtoFromJSON(json['transaction']),
+        'hasPendingTransaction': json['hasPendingTransaction'],
+    };
+}
+
+export function AccountPaymentDtoToJSON(json: any): AccountPaymentDto {
+    return AccountPaymentDtoToJSONTyped(json, false);
+}
+
+export function AccountPaymentDtoToJSONTyped(value?: AccountPaymentDto | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'id': value['id'],
+        'status': value['status'],
+        'paymentMethodProfiles': ((value['paymentMethodProfiles'] as Array<any>).map(AccountPaymentMethodProfileDtoToJSON)),
+        'basePrice': MoneyDtoToJSON(value['basePrice']),
+        'totalPrice': MoneyDtoToJSON(value['totalPrice']),
+        'totalTaxPrice': MoneyDtoToJSON(value['totalTaxPrice']),
+        'items': ((value['items'] as Array<any>).map(InvoiceItemDtoToJSON)),
+        'allowedPaymentMethods': value['allowedPaymentMethods'],
+        'transaction': InvoiceTransactionDtoToJSON(value['transaction']),
+        'hasPendingTransaction': value['hasPendingTransaction'],
+    };
+}
+