From 832d748396292d0dc0ab52e2460742168e6df17b Mon Sep 17 00:00:00 2001 From: Stainless Bot Date: Thu, 21 Nov 2024 22:17:00 +0000 Subject: [PATCH] style(internal): reorder some params methods and improve consistency of implementations --- .../api/models/AccountHolderCreateParams.kt | 44 +++++------ .../AccountHolderListDocumentsParams.kt | 41 +++++----- .../api/models/AccountHolderListParams.kt | 60 +++++++------- .../api/models/AccountHolderResubmitParams.kt | 53 ++++++------- .../AccountHolderRetrieveDocumentParams.kt | 43 +++++----- .../api/models/AccountHolderRetrieveParams.kt | 40 +++++----- ...rSimulateEnrollmentDocumentReviewParams.kt | 63 ++++++++------- ...untHolderSimulateEnrollmentReviewParams.kt | 61 ++++++++------- .../api/models/AccountHolderUpdateParams.kt | 53 ++++++------- .../AccountHolderUploadDocumentParams.kt | 52 +++++++------ .../lithic/api/models/AccountListParams.kt | 48 ++++++------ .../api/models/AccountRetrieveParams.kt | 40 +++++----- .../AccountRetrieveSpendLimitsParams.kt | 41 +++++----- .../lithic/api/models/AccountUpdateParams.kt | 56 ++++++------- .../api/models/AggregateBalanceListParams.kt | 40 +++++----- .../api/models/AuthRuleV2ApplyParams.kt | 47 ++++++----- .../api/models/AuthRuleV2CreateParams.kt | 45 ++++++----- .../api/models/AuthRuleV2DraftParams.kt | 48 ++++++------ .../lithic/api/models/AuthRuleV2ListParams.kt | 48 ++++++------ .../api/models/AuthRuleV2PromoteParams.kt | 47 +++++------ .../api/models/AuthRuleV2ReportParams.kt | 47 +++++------ .../api/models/AuthRuleV2RetrieveParams.kt | 40 +++++----- .../api/models/AuthRuleV2UpdateParams.kt | 49 ++++++------ ...uthStreamEnrollmentRetrieveSecretParams.kt | 36 +++++---- .../AuthStreamEnrollmentRotateSecretParams.kt | 44 +++++------ .../lithic/api/models/BalanceListParams.kt | 46 +++++------ .../api/models/BookTransferCreateParams.kt | 61 ++++++++------- .../api/models/BookTransferListParams.kt | 60 +++++++------- .../api/models/BookTransferRetrieveParams.kt | 40 +++++----- .../api/models/BookTransferReverseParams.kt | 49 ++++++------ .../models/CardAggregateBalanceListParams.kt | 42 +++++----- .../api/models/CardBalanceListParams.kt | 44 +++++------ .../com/lithic/api/models/CardCreateParams.kt | 78 +++++++++---------- .../com/lithic/api/models/CardEmbedParams.kt | 42 +++++----- .../CardFinancialTransactionListParams.kt | 55 ++++++------- .../CardFinancialTransactionRetrieveParams.kt | 43 +++++----- .../com/lithic/api/models/CardListParams.kt | 52 ++++++------- .../api/models/CardProgramListParams.kt | 44 +++++------ .../api/models/CardProgramRetrieveParams.kt | 40 +++++----- .../lithic/api/models/CardProvisionParams.kt | 58 +++++++------- .../lithic/api/models/CardReissueParams.kt | 54 ++++++------- .../com/lithic/api/models/CardRenewParams.kt | 58 +++++++------- .../lithic/api/models/CardRetrieveParams.kt | 40 +++++----- .../models/CardRetrieveSpendLimitsParams.kt | 40 +++++----- .../api/models/CardSearchByPanParams.kt | 46 +++++------ .../com/lithic/api/models/CardUpdateParams.kt | 60 +++++++------- .../api/models/ClientApiStatusParams.kt | 34 ++++---- ...editProductExtendedCreditRetrieveParams.kt | 42 +++++----- .../CreditProductPrimeRateCreateParams.kt | 54 ++++++------- .../CreditProductPrimeRateRetrieveParams.kt | 45 +++++------ .../api/models/DigitalCardArtListParams.kt | 44 +++++------ .../models/DigitalCardArtRetrieveParams.kt | 40 +++++----- .../lithic/api/models/DisputeCreateParams.kt | 54 ++++++------- .../api/models/DisputeDeleteEvidenceParams.kt | 49 ++++++------ .../lithic/api/models/DisputeDeleteParams.kt | 46 +++++------ .../DisputeInitiateEvidenceUploadParams.kt | 50 ++++++------ .../api/models/DisputeListEvidencesParams.kt | 50 ++++++------ .../lithic/api/models/DisputeListParams.kt | 55 ++++++------- .../models/DisputeRetrieveEvidenceParams.kt | 42 +++++----- .../api/models/DisputeRetrieveParams.kt | 40 +++++----- .../lithic/api/models/DisputeUpdateParams.kt | 54 ++++++------- .../api/models/EventListAttemptsParams.kt | 52 ++++++------- .../com/lithic/api/models/EventListParams.kt | 54 ++++++------- .../lithic/api/models/EventRetrieveParams.kt | 40 +++++----- .../models/EventSubscriptionCreateParams.kt | 56 ++++++------- .../models/EventSubscriptionDeleteParams.kt | 47 +++++------ .../EventSubscriptionListAttemptsParams.kt | 53 ++++++------- .../api/models/EventSubscriptionListParams.kt | 44 +++++------ .../models/EventSubscriptionRecoverParams.kt | 51 ++++++------ .../EventSubscriptionReplayMissingParams.kt | 53 ++++++------- .../models/EventSubscriptionRetrieveParams.kt | 41 +++++----- .../EventSubscriptionRetrieveSecretParams.kt | 42 +++++----- .../EventSubscriptionRotateSecretParams.kt | 48 ++++++------ ...tSubscriptionSendSimulatedExampleParams.kt | 53 ++++++------- .../models/EventSubscriptionUpdateParams.kt | 58 +++++++------- .../models/ExternalBankAccountCreateParams.kt | 45 +++++------ .../models/ExternalBankAccountListParams.kt | 69 ++++++++-------- ...rnalBankAccountMicroDepositCreateParams.kt | 57 +++++++------- .../ExternalBankAccountRetrieveParams.kt | 41 +++++----- ...rnalBankAccountRetryMicroDepositsParams.kt | 53 ++++++------- .../ExternalBankAccountRetryPrenoteParams.kt | 50 ++++++------ .../models/ExternalBankAccountUpdateParams.kt | 65 ++++++++-------- .../api/models/ExternalPaymentCancelParams.kt | 51 ++++++------ .../api/models/ExternalPaymentCreateParams.kt | 63 +++++++-------- .../api/models/ExternalPaymentListParams.kt | 58 +++++++------- .../models/ExternalPaymentReleaseParams.kt | 51 ++++++------ .../models/ExternalPaymentRetrieveParams.kt | 40 +++++----- .../models/ExternalPaymentReverseParams.kt | 51 ++++++------ .../api/models/ExternalPaymentSettleParams.kt | 53 ++++++------- .../FinancialAccountBalanceListParams.kt | 45 +++++------ .../models/FinancialAccountChargeOffParams.kt | 50 ++++++------ .../models/FinancialAccountCreateParams.kt | 55 ++++++------- ...ccountCreditConfigurationRetrieveParams.kt | 44 +++++------ ...lAccountCreditConfigurationUpdateParams.kt | 61 +++++++-------- .../api/models/FinancialAccountListParams.kt | 44 +++++------ .../FinancialAccountLoanTapeListParams.kt | 52 ++++++------- .../FinancialAccountLoanTapeRetrieveParams.kt | 44 +++++------ .../models/FinancialAccountRetrieveParams.kt | 40 +++++----- ...ncialAccountStatementLineItemListParams.kt | 50 ++++++------ .../FinancialAccountStatementListParams.kt | 54 ++++++------- ...FinancialAccountStatementRetrieveParams.kt | 45 +++++------ .../models/FinancialAccountUpdateParams.kt | 49 ++++++------ .../models/FinancialTransactionListParams.kt | 54 ++++++------- .../FinancialTransactionRetrieveParams.kt | 44 +++++------ .../models/ManagementOperationCreateParams.kt | 66 ++++++++-------- .../models/ManagementOperationListParams.kt | 56 ++++++------- .../ManagementOperationRetrieveParams.kt | 41 +++++----- .../ManagementOperationReverseParams.kt | 53 ++++++------- .../lithic/api/models/PaymentCreateParams.kt | 62 +++++++-------- .../lithic/api/models/PaymentListParams.kt | 60 +++++++------- .../api/models/PaymentRetrieveParams.kt | 40 +++++----- .../lithic/api/models/PaymentRetryParams.kt | 46 +++++------ .../api/models/PaymentSimulateActionParams.kt | 53 ++++++------- .../models/PaymentSimulateReceiptParams.kt | 55 ++++++------- .../models/PaymentSimulateReleaseParams.kt | 47 +++++------ .../api/models/PaymentSimulateReturnParams.kt | 49 ++++++------ .../ReportSettlementListDetailsParams.kt | 47 +++++------ .../models/ReportSettlementSummaryParams.kt | 40 +++++----- .../ResponderEndpointCheckStatusParams.kt | 41 +++++----- .../models/ResponderEndpointCreateParams.kt | 49 ++++++------ .../models/ResponderEndpointDeleteParams.kt | 47 +++++------ .../ThreeDSAuthenticationRetrieveParams.kt | 41 +++++----- .../ThreeDSAuthenticationSimulateParams.kt | 54 ++++++------- ...reeDSDecisioningChallengeResponseParams.kt | 53 ++++++------- .../ThreeDSDecisioningRetrieveSecretParams.kt | 35 +++++---- .../ThreeDSDecisioningRotateSecretParams.kt | 42 +++++----- ...reeDSDecisioningSimulateChallengeParams.kt | 51 ++++++------ ...isioningSimulateChallengeResponseParams.kt | 55 +++++++------ .../api/models/TokenizationActivateParams.kt | 47 +++++------ .../models/TokenizationDeactivateParams.kt | 47 +++++------ ...nizationDecisioningRetrieveSecretParams.kt | 36 +++++---- ...kenizationDecisioningRotateSecretParams.kt | 45 +++++------ .../api/models/TokenizationListParams.kt | 54 ++++++------- .../api/models/TokenizationPauseParams.kt | 47 +++++------ .../TokenizationResendActivationCodeParams.kt | 52 ++++++------- .../api/models/TokenizationRetrieveParams.kt | 40 +++++----- .../api/models/TokenizationSimulateParams.kt | 61 ++++++++------- .../api/models/TokenizationUnpauseParams.kt | 47 +++++------ .../TokenizationUpdateDigitalCardArtParams.kt | 52 ++++++------- ...ionEnhancedCommercialDataRetrieveParams.kt | 44 +++++------ ...entEnhancedCommercialDataRetrieveParams.kt | 45 ++++++----- .../api/models/TransactionListParams.kt | 54 ++++++------- .../api/models/TransactionRetrieveParams.kt | 40 +++++----- ...actionSimulateAuthorizationAdviceParams.kt | 55 +++++++------ .../TransactionSimulateAuthorizationParams.kt | 67 ++++++++-------- .../TransactionSimulateClearingParams.kt | 50 ++++++------ ...actionSimulateCreditAuthorizationParams.kt | 62 +++++++-------- .../models/TransactionSimulateReturnParams.kt | 52 +++++++------ ...TransactionSimulateReturnReversalParams.kt | 51 ++++++------ .../models/TransactionSimulateVoidParams.kt | 51 ++++++------ .../lithic/api/models/TransferCreateParams.kt | 54 ++++++------- 151 files changed, 3763 insertions(+), 3680 deletions(-) diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderCreateParams.kt index 0cb973fd..f43bf493 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderCreateParams.kt @@ -35,6 +35,10 @@ constructor( fun kycExempt(): KycExempt? = kycExempt + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getBody(): AccountHolderCreateBody { return AccountHolderCreateBody( kyb, @@ -165,23 +169,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderCreateParams && kyb == other.kyb && kyc == other.kyc && kycExempt == other.kycExempt && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(kyb, kyc, kycExempt, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AccountHolderCreateParams{kyb=$kyb, kyc=$kyc, kycExempt=$kycExempt, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -199,11 +186,11 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountHolderCreateParams: AccountHolderCreateParams) = apply { - this.kyb = accountHolderCreateParams.kyb - this.kyc = accountHolderCreateParams.kyc - this.kycExempt = accountHolderCreateParams.kycExempt - additionalHeaders(accountHolderCreateParams.additionalHeaders) - additionalQueryParams(accountHolderCreateParams.additionalQueryParams) + kyb = accountHolderCreateParams.kyb + kyc = accountHolderCreateParams.kyc + kycExempt = accountHolderCreateParams.kycExempt + additionalHeaders = accountHolderCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = accountHolderCreateParams.additionalQueryParams.toBuilder() } fun forKyb(kyb: Kyb) = apply { @@ -331,4 +318,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderCreateParams && kyb == other.kyb && kyc == other.kyc && kycExempt == other.kycExempt && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(kyb, kyc, kycExempt, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AccountHolderCreateParams{kyb=$kyb, kyc=$kyc, kycExempt=$kycExempt, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderListDocumentsParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderListDocumentsParams.kt index 3964fa50..7463b38a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderListDocumentsParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderListDocumentsParams.kt @@ -17,6 +17,10 @@ constructor( fun accountHolderToken(): String = accountHolderToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderListDocumentsParams && accountHolderToken == other.accountHolderToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AccountHolderListDocumentsParams{accountHolderToken=$accountHolderToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -61,9 +48,10 @@ constructor( internal fun from(accountHolderListDocumentsParams: AccountHolderListDocumentsParams) = apply { - this.accountHolderToken = accountHolderListDocumentsParams.accountHolderToken - additionalHeaders(accountHolderListDocumentsParams.additionalHeaders) - additionalQueryParams(accountHolderListDocumentsParams.additionalQueryParams) + accountHolderToken = accountHolderListDocumentsParams.accountHolderToken + additionalHeaders = accountHolderListDocumentsParams.additionalHeaders.toBuilder() + additionalQueryParams = + accountHolderListDocumentsParams.additionalQueryParams.toBuilder() } fun accountHolderToken(accountHolderToken: String) = apply { @@ -177,4 +165,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderListDocumentsParams && accountHolderToken == other.accountHolderToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AccountHolderListDocumentsParams{accountHolderToken=$accountHolderToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderListParams.kt index 9a6728d3..aa11c3bf 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderListParams.kt @@ -49,6 +49,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -74,23 +78,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderListParams && begin == other.begin && email == other.email && end == other.end && endingBefore == other.endingBefore && externalId == other.externalId && firstName == other.firstName && lastName == other.lastName && legalBusinessName == other.legalBusinessName && limit == other.limit && phoneNumber == other.phoneNumber && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, email, end, endingBefore, externalId, firstName, lastName, legalBusinessName, limit, phoneNumber, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AccountHolderListParams{begin=$begin, email=$email, end=$end, endingBefore=$endingBefore, externalId=$externalId, firstName=$firstName, lastName=$lastName, legalBusinessName=$legalBusinessName, limit=$limit, phoneNumber=$phoneNumber, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -116,19 +103,19 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountHolderListParams: AccountHolderListParams) = apply { - this.begin = accountHolderListParams.begin - this.email = accountHolderListParams.email - this.end = accountHolderListParams.end - this.endingBefore = accountHolderListParams.endingBefore - this.externalId = accountHolderListParams.externalId - this.firstName = accountHolderListParams.firstName - this.lastName = accountHolderListParams.lastName - this.legalBusinessName = accountHolderListParams.legalBusinessName - this.limit = accountHolderListParams.limit - this.phoneNumber = accountHolderListParams.phoneNumber - this.startingAfter = accountHolderListParams.startingAfter - additionalHeaders(accountHolderListParams.additionalHeaders) - additionalQueryParams(accountHolderListParams.additionalQueryParams) + begin = accountHolderListParams.begin + email = accountHolderListParams.email + end = accountHolderListParams.end + endingBefore = accountHolderListParams.endingBefore + externalId = accountHolderListParams.externalId + firstName = accountHolderListParams.firstName + lastName = accountHolderListParams.lastName + legalBusinessName = accountHolderListParams.legalBusinessName + limit = accountHolderListParams.limit + phoneNumber = accountHolderListParams.phoneNumber + startingAfter = accountHolderListParams.startingAfter + additionalHeaders = accountHolderListParams.additionalHeaders.toBuilder() + additionalQueryParams = accountHolderListParams.additionalQueryParams.toBuilder() } /** @@ -304,4 +291,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderListParams && begin == other.begin && email == other.email && end == other.end && endingBefore == other.endingBefore && externalId == other.externalId && firstName == other.firstName && lastName == other.lastName && legalBusinessName == other.legalBusinessName && limit == other.limit && phoneNumber == other.phoneNumber && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, email, end, endingBefore, externalId, firstName, lastName, legalBusinessName, limit, phoneNumber, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AccountHolderListParams{begin=$begin, email=$email, end=$end, endingBefore=$endingBefore, externalId=$externalId, firstName=$firstName, lastName=$lastName, legalBusinessName=$legalBusinessName, limit=$limit, phoneNumber=$phoneNumber, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderResubmitParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderResubmitParams.kt index c3a07c02..b7cc4afc 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderResubmitParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderResubmitParams.kt @@ -38,6 +38,12 @@ constructor( fun workflow(): Workflow = workflow + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): AccountHolderResubmitBody { return AccountHolderResubmitBody( individual, @@ -166,25 +172,6 @@ constructor( "AccountHolderResubmitBody{individual=$individual, tosTimestamp=$tosTimestamp, workflow=$workflow, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderResubmitParams && accountHolderToken == other.accountHolderToken && individual == other.individual && tosTimestamp == other.tosTimestamp && workflow == other.workflow && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, individual, tosTimestamp, workflow, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AccountHolderResubmitParams{accountHolderToken=$accountHolderToken, individual=$individual, tosTimestamp=$tosTimestamp, workflow=$workflow, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -204,13 +191,14 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(accountHolderResubmitParams: AccountHolderResubmitParams) = apply { - this.accountHolderToken = accountHolderResubmitParams.accountHolderToken - this.individual = accountHolderResubmitParams.individual - this.tosTimestamp = accountHolderResubmitParams.tosTimestamp - this.workflow = accountHolderResubmitParams.workflow - additionalHeaders(accountHolderResubmitParams.additionalHeaders) - additionalQueryParams(accountHolderResubmitParams.additionalQueryParams) - additionalBodyProperties(accountHolderResubmitParams.additionalBodyProperties) + accountHolderToken = accountHolderResubmitParams.accountHolderToken + individual = accountHolderResubmitParams.individual + tosTimestamp = accountHolderResubmitParams.tosTimestamp + workflow = accountHolderResubmitParams.workflow + additionalHeaders = accountHolderResubmitParams.additionalHeaders.toBuilder() + additionalQueryParams = accountHolderResubmitParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + accountHolderResubmitParams.additionalBodyProperties.toMutableMap() } fun accountHolderToken(accountHolderToken: String) = apply { @@ -577,4 +565,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderResubmitParams && accountHolderToken == other.accountHolderToken && individual == other.individual && tosTimestamp == other.tosTimestamp && workflow == other.workflow && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, individual, tosTimestamp, workflow, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AccountHolderResubmitParams{accountHolderToken=$accountHolderToken, individual=$individual, tosTimestamp=$tosTimestamp, workflow=$workflow, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderRetrieveDocumentParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderRetrieveDocumentParams.kt index 79281faf..2dab0ae2 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderRetrieveDocumentParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderRetrieveDocumentParams.kt @@ -20,6 +20,10 @@ constructor( fun documentToken(): String = documentToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -32,23 +36,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderRetrieveDocumentParams && accountHolderToken == other.accountHolderToken && documentToken == other.documentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, documentToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AccountHolderRetrieveDocumentParams{accountHolderToken=$accountHolderToken, documentToken=$documentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -67,10 +54,11 @@ constructor( internal fun from( accountHolderRetrieveDocumentParams: AccountHolderRetrieveDocumentParams ) = apply { - this.accountHolderToken = accountHolderRetrieveDocumentParams.accountHolderToken - this.documentToken = accountHolderRetrieveDocumentParams.documentToken - additionalHeaders(accountHolderRetrieveDocumentParams.additionalHeaders) - additionalQueryParams(accountHolderRetrieveDocumentParams.additionalQueryParams) + accountHolderToken = accountHolderRetrieveDocumentParams.accountHolderToken + documentToken = accountHolderRetrieveDocumentParams.documentToken + additionalHeaders = accountHolderRetrieveDocumentParams.additionalHeaders.toBuilder() + additionalQueryParams = + accountHolderRetrieveDocumentParams.additionalQueryParams.toBuilder() } fun accountHolderToken(accountHolderToken: String) = apply { @@ -187,4 +175,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderRetrieveDocumentParams && accountHolderToken == other.accountHolderToken && documentToken == other.documentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, documentToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AccountHolderRetrieveDocumentParams{accountHolderToken=$accountHolderToken, documentToken=$documentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderRetrieveParams.kt index 136e720b..9bf50543 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun accountHolderToken(): String = accountHolderToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderRetrieveParams && accountHolderToken == other.accountHolderToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AccountHolderRetrieveParams{accountHolderToken=$accountHolderToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountHolderRetrieveParams: AccountHolderRetrieveParams) = apply { - this.accountHolderToken = accountHolderRetrieveParams.accountHolderToken - additionalHeaders(accountHolderRetrieveParams.additionalHeaders) - additionalQueryParams(accountHolderRetrieveParams.additionalQueryParams) + accountHolderToken = accountHolderRetrieveParams.accountHolderToken + additionalHeaders = accountHolderRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = accountHolderRetrieveParams.additionalQueryParams.toBuilder() } fun accountHolderToken(accountHolderToken: String) = apply { @@ -176,4 +163,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderRetrieveParams && accountHolderToken == other.accountHolderToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AccountHolderRetrieveParams{accountHolderToken=$accountHolderToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderSimulateEnrollmentDocumentReviewParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderSimulateEnrollmentDocumentReviewParams.kt index da7f04ed..fde21955 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderSimulateEnrollmentDocumentReviewParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderSimulateEnrollmentDocumentReviewParams.kt @@ -38,6 +38,12 @@ constructor( fun statusReason(): DocumentUploadStatusReasons? = statusReason + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): AccountHolderSimulateEnrollmentDocumentReviewBody { return AccountHolderSimulateEnrollmentDocumentReviewBody( documentUploadToken, @@ -183,25 +189,6 @@ constructor( "AccountHolderSimulateEnrollmentDocumentReviewBody{documentUploadToken=$documentUploadToken, status=$status, acceptedEntityStatusReasons=$acceptedEntityStatusReasons, statusReason=$statusReason, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderSimulateEnrollmentDocumentReviewParams && documentUploadToken == other.documentUploadToken && status == other.status && acceptedEntityStatusReasons == other.acceptedEntityStatusReasons && statusReason == other.statusReason && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(documentUploadToken, status, acceptedEntityStatusReasons, statusReason, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AccountHolderSimulateEnrollmentDocumentReviewParams{documentUploadToken=$documentUploadToken, status=$status, acceptedEntityStatusReasons=$acceptedEntityStatusReasons, statusReason=$statusReason, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -224,21 +211,21 @@ constructor( accountHolderSimulateEnrollmentDocumentReviewParams: AccountHolderSimulateEnrollmentDocumentReviewParams ) = apply { - this.documentUploadToken = + documentUploadToken = accountHolderSimulateEnrollmentDocumentReviewParams.documentUploadToken - this.status = accountHolderSimulateEnrollmentDocumentReviewParams.status - this.acceptedEntityStatusReasons( + status = accountHolderSimulateEnrollmentDocumentReviewParams.status + acceptedEntityStatusReasons = accountHolderSimulateEnrollmentDocumentReviewParams.acceptedEntityStatusReasons - ?: listOf() - ) - this.statusReason = accountHolderSimulateEnrollmentDocumentReviewParams.statusReason - additionalHeaders(accountHolderSimulateEnrollmentDocumentReviewParams.additionalHeaders) - additionalQueryParams( + ?.toMutableList() ?: mutableListOf() + statusReason = accountHolderSimulateEnrollmentDocumentReviewParams.statusReason + additionalHeaders = + accountHolderSimulateEnrollmentDocumentReviewParams.additionalHeaders.toBuilder() + additionalQueryParams = accountHolderSimulateEnrollmentDocumentReviewParams.additionalQueryParams - ) - additionalBodyProperties( + .toBuilder() + additionalBodyProperties = accountHolderSimulateEnrollmentDocumentReviewParams.additionalBodyProperties - ) + .toMutableMap() } /** The account holder document upload which to perform the simulation upon. */ @@ -394,8 +381,7 @@ constructor( "`documentUploadToken` is required but was not set" }, checkNotNull(status) { "`status` is required but was not set" }, - if (acceptedEntityStatusReasons.size == 0) null - else acceptedEntityStatusReasons.toImmutable(), + acceptedEntityStatusReasons.toImmutable().ifEmpty { null }, statusReason, additionalHeaders.build(), additionalQueryParams.build(), @@ -591,4 +577,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderSimulateEnrollmentDocumentReviewParams && documentUploadToken == other.documentUploadToken && status == other.status && acceptedEntityStatusReasons == other.acceptedEntityStatusReasons && statusReason == other.statusReason && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(documentUploadToken, status, acceptedEntityStatusReasons, statusReason, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AccountHolderSimulateEnrollmentDocumentReviewParams{documentUploadToken=$documentUploadToken, status=$status, acceptedEntityStatusReasons=$acceptedEntityStatusReasons, statusReason=$statusReason, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderSimulateEnrollmentReviewParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderSimulateEnrollmentReviewParams.kt index d9b650d1..cc44447a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderSimulateEnrollmentReviewParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderSimulateEnrollmentReviewParams.kt @@ -35,6 +35,12 @@ constructor( fun statusReasons(): List? = statusReasons + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): AccountHolderSimulateEnrollmentReviewBody { return AccountHolderSimulateEnrollmentReviewBody( accountHolderToken, @@ -157,25 +163,6 @@ constructor( "AccountHolderSimulateEnrollmentReviewBody{accountHolderToken=$accountHolderToken, status=$status, statusReasons=$statusReasons, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderSimulateEnrollmentReviewParams && accountHolderToken == other.accountHolderToken && status == other.status && statusReasons == other.statusReasons && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, status, statusReasons, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AccountHolderSimulateEnrollmentReviewParams{accountHolderToken=$accountHolderToken, status=$status, statusReasons=$statusReasons, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -196,16 +183,17 @@ constructor( internal fun from( accountHolderSimulateEnrollmentReviewParams: AccountHolderSimulateEnrollmentReviewParams ) = apply { - this.accountHolderToken = accountHolderSimulateEnrollmentReviewParams.accountHolderToken - this.status = accountHolderSimulateEnrollmentReviewParams.status - this.statusReasons( - accountHolderSimulateEnrollmentReviewParams.statusReasons ?: listOf() - ) - additionalHeaders(accountHolderSimulateEnrollmentReviewParams.additionalHeaders) - additionalQueryParams(accountHolderSimulateEnrollmentReviewParams.additionalQueryParams) - additionalBodyProperties( - accountHolderSimulateEnrollmentReviewParams.additionalBodyProperties - ) + accountHolderToken = accountHolderSimulateEnrollmentReviewParams.accountHolderToken + status = accountHolderSimulateEnrollmentReviewParams.status + statusReasons = + accountHolderSimulateEnrollmentReviewParams.statusReasons?.toMutableList() + ?: mutableListOf() + additionalHeaders = + accountHolderSimulateEnrollmentReviewParams.additionalHeaders.toBuilder() + additionalQueryParams = + accountHolderSimulateEnrollmentReviewParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + accountHolderSimulateEnrollmentReviewParams.additionalBodyProperties.toMutableMap() } /** The account holder which to perform the simulation upon. */ @@ -357,7 +345,7 @@ constructor( AccountHolderSimulateEnrollmentReviewParams( accountHolderToken, status, - if (statusReasons.size == 0) null else statusReasons.toImmutable(), + statusReasons.toImmutable().ifEmpty { null }, additionalHeaders.build(), additionalQueryParams.build(), additionalBodyProperties.toImmutable(), @@ -616,4 +604,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderSimulateEnrollmentReviewParams && accountHolderToken == other.accountHolderToken && status == other.status && statusReasons == other.statusReasons && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, status, statusReasons, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AccountHolderSimulateEnrollmentReviewParams{accountHolderToken=$accountHolderToken, status=$status, statusReasons=$statusReasons, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderUpdateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderUpdateParams.kt index e0fe99f3..3bf531b7 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderUpdateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderUpdateParams.kt @@ -34,6 +34,12 @@ constructor( fun phoneNumber(): String? = phoneNumber + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): AccountHolderUpdateBody { return AccountHolderUpdateBody( businessAccountToken, @@ -175,25 +181,6 @@ constructor( "AccountHolderUpdateBody{businessAccountToken=$businessAccountToken, email=$email, phoneNumber=$phoneNumber, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderUpdateParams && accountHolderToken == other.accountHolderToken && businessAccountToken == other.businessAccountToken && email == other.email && phoneNumber == other.phoneNumber && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, businessAccountToken, email, phoneNumber, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AccountHolderUpdateParams{accountHolderToken=$accountHolderToken, businessAccountToken=$businessAccountToken, email=$email, phoneNumber=$phoneNumber, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -213,13 +200,14 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(accountHolderUpdateParams: AccountHolderUpdateParams) = apply { - this.accountHolderToken = accountHolderUpdateParams.accountHolderToken - this.businessAccountToken = accountHolderUpdateParams.businessAccountToken - this.email = accountHolderUpdateParams.email - this.phoneNumber = accountHolderUpdateParams.phoneNumber - additionalHeaders(accountHolderUpdateParams.additionalHeaders) - additionalQueryParams(accountHolderUpdateParams.additionalQueryParams) - additionalBodyProperties(accountHolderUpdateParams.additionalBodyProperties) + accountHolderToken = accountHolderUpdateParams.accountHolderToken + businessAccountToken = accountHolderUpdateParams.businessAccountToken + email = accountHolderUpdateParams.email + phoneNumber = accountHolderUpdateParams.phoneNumber + additionalHeaders = accountHolderUpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = accountHolderUpdateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + accountHolderUpdateParams.additionalBodyProperties.toMutableMap() } fun accountHolderToken(accountHolderToken: String) = apply { @@ -381,4 +369,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderUpdateParams && accountHolderToken == other.accountHolderToken && businessAccountToken == other.businessAccountToken && email == other.email && phoneNumber == other.phoneNumber && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, businessAccountToken, email, phoneNumber, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AccountHolderUpdateParams{accountHolderToken=$accountHolderToken, businessAccountToken=$businessAccountToken, email=$email, phoneNumber=$phoneNumber, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderUploadDocumentParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderUploadDocumentParams.kt index eba4cc8b..4fe666a7 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderUploadDocumentParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountHolderUploadDocumentParams.kt @@ -35,6 +35,12 @@ constructor( fun entityToken(): String = entityToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): AccountHolderUploadDocumentBody { return AccountHolderUploadDocumentBody( documentType, @@ -143,25 +149,6 @@ constructor( "AccountHolderUploadDocumentBody{documentType=$documentType, entityToken=$entityToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountHolderUploadDocumentParams && accountHolderToken == other.accountHolderToken && documentType == other.documentType && entityToken == other.entityToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, documentType, entityToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AccountHolderUploadDocumentParams{accountHolderToken=$accountHolderToken, documentType=$documentType, entityToken=$entityToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -181,12 +168,14 @@ constructor( internal fun from(accountHolderUploadDocumentParams: AccountHolderUploadDocumentParams) = apply { - this.accountHolderToken = accountHolderUploadDocumentParams.accountHolderToken - this.documentType = accountHolderUploadDocumentParams.documentType - this.entityToken = accountHolderUploadDocumentParams.entityToken - additionalHeaders(accountHolderUploadDocumentParams.additionalHeaders) - additionalQueryParams(accountHolderUploadDocumentParams.additionalQueryParams) - additionalBodyProperties(accountHolderUploadDocumentParams.additionalBodyProperties) + accountHolderToken = accountHolderUploadDocumentParams.accountHolderToken + documentType = accountHolderUploadDocumentParams.documentType + entityToken = accountHolderUploadDocumentParams.entityToken + additionalHeaders = accountHolderUploadDocumentParams.additionalHeaders.toBuilder() + additionalQueryParams = + accountHolderUploadDocumentParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + accountHolderUploadDocumentParams.additionalBodyProperties.toMutableMap() } fun accountHolderToken(accountHolderToken: String) = apply { @@ -486,4 +475,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountHolderUploadDocumentParams && accountHolderToken == other.accountHolderToken && documentType == other.documentType && entityToken == other.entityToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountHolderToken, documentType, entityToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AccountHolderUploadDocumentParams{accountHolderToken=$accountHolderToken, documentType=$documentType, entityToken=$entityToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountListParams.kt index 94f018e1..963538f2 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountListParams.kt @@ -31,6 +31,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -48,23 +52,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountListParams && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, end, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AccountListParams{begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -84,13 +71,13 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountListParams: AccountListParams) = apply { - this.begin = accountListParams.begin - this.end = accountListParams.end - this.endingBefore = accountListParams.endingBefore - this.pageSize = accountListParams.pageSize - this.startingAfter = accountListParams.startingAfter - additionalHeaders(accountListParams.additionalHeaders) - additionalQueryParams(accountListParams.additionalQueryParams) + begin = accountListParams.begin + end = accountListParams.end + endingBefore = accountListParams.endingBefore + pageSize = accountListParams.pageSize + startingAfter = accountListParams.startingAfter + additionalHeaders = accountListParams.additionalHeaders.toBuilder() + additionalQueryParams = accountListParams.additionalQueryParams.toBuilder() } /** @@ -229,4 +216,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountListParams && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, end, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AccountListParams{begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountRetrieveParams.kt index 2cb4b1f2..b9aad117 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun accountToken(): String = accountToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountRetrieveParams && accountToken == other.accountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AccountRetrieveParams{accountToken=$accountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountRetrieveParams: AccountRetrieveParams) = apply { - this.accountToken = accountRetrieveParams.accountToken - additionalHeaders(accountRetrieveParams.additionalHeaders) - additionalQueryParams(accountRetrieveParams.additionalQueryParams) + accountToken = accountRetrieveParams.accountToken + additionalHeaders = accountRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = accountRetrieveParams.additionalQueryParams.toBuilder() } fun accountToken(accountToken: String) = apply { this.accountToken = accountToken } @@ -172,4 +159,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountRetrieveParams && accountToken == other.accountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AccountRetrieveParams{accountToken=$accountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountRetrieveSpendLimitsParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountRetrieveSpendLimitsParams.kt index c3cb6446..f964451b 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountRetrieveSpendLimitsParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountRetrieveSpendLimitsParams.kt @@ -17,6 +17,10 @@ constructor( fun accountToken(): String = accountToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountRetrieveSpendLimitsParams && accountToken == other.accountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AccountRetrieveSpendLimitsParams{accountToken=$accountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -61,9 +48,10 @@ constructor( internal fun from(accountRetrieveSpendLimitsParams: AccountRetrieveSpendLimitsParams) = apply { - this.accountToken = accountRetrieveSpendLimitsParams.accountToken - additionalHeaders(accountRetrieveSpendLimitsParams.additionalHeaders) - additionalQueryParams(accountRetrieveSpendLimitsParams.additionalQueryParams) + accountToken = accountRetrieveSpendLimitsParams.accountToken + additionalHeaders = accountRetrieveSpendLimitsParams.additionalHeaders.toBuilder() + additionalQueryParams = + accountRetrieveSpendLimitsParams.additionalQueryParams.toBuilder() } fun accountToken(accountToken: String) = apply { this.accountToken = accountToken } @@ -173,4 +161,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountRetrieveSpendLimitsParams && accountToken == other.accountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AccountRetrieveSpendLimitsParams{accountToken=$accountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountUpdateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountUpdateParams.kt index 6f73851b..e2666785 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountUpdateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AccountUpdateParams.kt @@ -44,6 +44,12 @@ constructor( fun verificationAddress(): VerificationAddress? = verificationAddress + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): AccountUpdateBody { return AccountUpdateBody( dailySpendLimit, @@ -228,25 +234,6 @@ constructor( "AccountUpdateBody{dailySpendLimit=$dailySpendLimit, lifetimeSpendLimit=$lifetimeSpendLimit, monthlySpendLimit=$monthlySpendLimit, state=$state, verificationAddress=$verificationAddress, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AccountUpdateParams && accountToken == other.accountToken && dailySpendLimit == other.dailySpendLimit && lifetimeSpendLimit == other.lifetimeSpendLimit && monthlySpendLimit == other.monthlySpendLimit && state == other.state && verificationAddress == other.verificationAddress && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, dailySpendLimit, lifetimeSpendLimit, monthlySpendLimit, state, verificationAddress, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AccountUpdateParams{accountToken=$accountToken, dailySpendLimit=$dailySpendLimit, lifetimeSpendLimit=$lifetimeSpendLimit, monthlySpendLimit=$monthlySpendLimit, state=$state, verificationAddress=$verificationAddress, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -268,15 +255,15 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(accountUpdateParams: AccountUpdateParams) = apply { - this.accountToken = accountUpdateParams.accountToken - this.dailySpendLimit = accountUpdateParams.dailySpendLimit - this.lifetimeSpendLimit = accountUpdateParams.lifetimeSpendLimit - this.monthlySpendLimit = accountUpdateParams.monthlySpendLimit - this.state = accountUpdateParams.state - this.verificationAddress = accountUpdateParams.verificationAddress - additionalHeaders(accountUpdateParams.additionalHeaders) - additionalQueryParams(accountUpdateParams.additionalQueryParams) - additionalBodyProperties(accountUpdateParams.additionalBodyProperties) + accountToken = accountUpdateParams.accountToken + dailySpendLimit = accountUpdateParams.dailySpendLimit + lifetimeSpendLimit = accountUpdateParams.lifetimeSpendLimit + monthlySpendLimit = accountUpdateParams.monthlySpendLimit + state = accountUpdateParams.state + verificationAddress = accountUpdateParams.verificationAddress + additionalHeaders = accountUpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = accountUpdateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = accountUpdateParams.additionalBodyProperties.toMutableMap() } fun accountToken(accountToken: String) = apply { this.accountToken = accountToken } @@ -631,4 +618,17 @@ constructor( override fun toString() = "VerificationAddress{address1=$address1, address2=$address2, city=$city, country=$country, postalCode=$postalCode, state=$state, additionalProperties=$additionalProperties}" } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AccountUpdateParams && accountToken == other.accountToken && dailySpendLimit == other.dailySpendLimit && lifetimeSpendLimit == other.lifetimeSpendLimit && monthlySpendLimit == other.monthlySpendLimit && state == other.state && verificationAddress == other.verificationAddress && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, dailySpendLimit, lifetimeSpendLimit, monthlySpendLimit, state, verificationAddress, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AccountUpdateParams{accountToken=$accountToken, dailySpendLimit=$dailySpendLimit, lifetimeSpendLimit=$lifetimeSpendLimit, monthlySpendLimit=$monthlySpendLimit, state=$state, verificationAddress=$verificationAddress, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AggregateBalanceListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AggregateBalanceListParams.kt index 5d0590f3..401c99ee 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AggregateBalanceListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AggregateBalanceListParams.kt @@ -22,6 +22,10 @@ constructor( fun financialAccountType(): FinancialAccountType? = financialAccountType + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -33,23 +37,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AggregateBalanceListParams && financialAccountType == other.financialAccountType && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountType, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AggregateBalanceListParams{financialAccountType=$financialAccountType, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -65,9 +52,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(aggregateBalanceListParams: AggregateBalanceListParams) = apply { - this.financialAccountType = aggregateBalanceListParams.financialAccountType - additionalHeaders(aggregateBalanceListParams.additionalHeaders) - additionalQueryParams(aggregateBalanceListParams.additionalQueryParams) + financialAccountType = aggregateBalanceListParams.financialAccountType + additionalHeaders = aggregateBalanceListParams.additionalHeaders.toBuilder() + additionalQueryParams = aggregateBalanceListParams.additionalQueryParams.toBuilder() } /** Get the aggregate balance for a given Financial Account type. */ @@ -243,4 +230,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AggregateBalanceListParams && financialAccountType == other.financialAccountType && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountType, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AggregateBalanceListParams{financialAccountType=$financialAccountType, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ApplyParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ApplyParams.kt index c5377e6f..bdc69134 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ApplyParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ApplyParams.kt @@ -46,6 +46,10 @@ constructor( fun applyAuthRuleRequestProgramLevel(): ApplyAuthRuleRequestProgramLevel? = applyAuthRuleRequestProgramLevel + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getBody(): AuthRuleV2ApplyBody { return AuthRuleV2ApplyBody( applyAuthRuleRequestAccountTokens, @@ -218,23 +222,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthRuleV2ApplyParams && authRuleToken == other.authRuleToken && applyAuthRuleRequestAccountTokens == other.applyAuthRuleRequestAccountTokens && applyAuthRuleRequestCardTokens == other.applyAuthRuleRequestCardTokens && applyAuthRuleRequestProgramLevel == other.applyAuthRuleRequestProgramLevel && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, applyAuthRuleRequestAccountTokens, applyAuthRuleRequestCardTokens, applyAuthRuleRequestProgramLevel, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AuthRuleV2ApplyParams{authRuleToken=$authRuleToken, applyAuthRuleRequestAccountTokens=$applyAuthRuleRequestAccountTokens, applyAuthRuleRequestCardTokens=$applyAuthRuleRequestCardTokens, applyAuthRuleRequestProgramLevel=$applyAuthRuleRequestProgramLevel, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -253,15 +240,14 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(authRuleV2ApplyParams: AuthRuleV2ApplyParams) = apply { - this.authRuleToken = authRuleV2ApplyParams.authRuleToken - this.applyAuthRuleRequestAccountTokens = + authRuleToken = authRuleV2ApplyParams.authRuleToken + applyAuthRuleRequestAccountTokens = authRuleV2ApplyParams.applyAuthRuleRequestAccountTokens - this.applyAuthRuleRequestCardTokens = - authRuleV2ApplyParams.applyAuthRuleRequestCardTokens - this.applyAuthRuleRequestProgramLevel = + applyAuthRuleRequestCardTokens = authRuleV2ApplyParams.applyAuthRuleRequestCardTokens + applyAuthRuleRequestProgramLevel = authRuleV2ApplyParams.applyAuthRuleRequestProgramLevel - additionalHeaders(authRuleV2ApplyParams.additionalHeaders) - additionalQueryParams(authRuleV2ApplyParams.additionalQueryParams) + additionalHeaders = authRuleV2ApplyParams.additionalHeaders.toBuilder() + additionalQueryParams = authRuleV2ApplyParams.additionalQueryParams.toBuilder() } fun authRuleToken(authRuleToken: String) = apply { this.authRuleToken = authRuleToken } @@ -631,4 +617,17 @@ constructor( override fun toString() = "ApplyAuthRuleRequestProgramLevel{programLevel=$programLevel, additionalProperties=$additionalProperties}" } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthRuleV2ApplyParams && authRuleToken == other.authRuleToken && applyAuthRuleRequestAccountTokens == other.applyAuthRuleRequestAccountTokens && applyAuthRuleRequestCardTokens == other.applyAuthRuleRequestCardTokens && applyAuthRuleRequestProgramLevel == other.applyAuthRuleRequestProgramLevel && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, applyAuthRuleRequestAccountTokens, applyAuthRuleRequestCardTokens, applyAuthRuleRequestProgramLevel, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AuthRuleV2ApplyParams{authRuleToken=$authRuleToken, applyAuthRuleRequestAccountTokens=$applyAuthRuleRequestAccountTokens, applyAuthRuleRequestCardTokens=$applyAuthRuleRequestCardTokens, applyAuthRuleRequestProgramLevel=$applyAuthRuleRequestProgramLevel, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2CreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2CreateParams.kt index a264acf3..d660e0f9 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2CreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2CreateParams.kt @@ -47,6 +47,10 @@ constructor( fun createAuthRuleRequestProgramLevel(): CreateAuthRuleRequestProgramLevel? = createAuthRuleRequestProgramLevel + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getBody(): AuthRuleV2CreateBody { return AuthRuleV2CreateBody( createAuthRuleRequestAccountTokens, @@ -224,23 +228,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthRuleV2CreateParams && createAuthRuleRequestAccountTokens == other.createAuthRuleRequestAccountTokens && createAuthRuleRequestCardTokens == other.createAuthRuleRequestCardTokens && createAuthRuleRequestProgramLevel == other.createAuthRuleRequestProgramLevel && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(createAuthRuleRequestAccountTokens, createAuthRuleRequestCardTokens, createAuthRuleRequestProgramLevel, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AuthRuleV2CreateParams{createAuthRuleRequestAccountTokens=$createAuthRuleRequestAccountTokens, createAuthRuleRequestCardTokens=$createAuthRuleRequestCardTokens, createAuthRuleRequestProgramLevel=$createAuthRuleRequestProgramLevel, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -258,14 +245,13 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(authRuleV2CreateParams: AuthRuleV2CreateParams) = apply { - this.createAuthRuleRequestAccountTokens = + createAuthRuleRequestAccountTokens = authRuleV2CreateParams.createAuthRuleRequestAccountTokens - this.createAuthRuleRequestCardTokens = - authRuleV2CreateParams.createAuthRuleRequestCardTokens - this.createAuthRuleRequestProgramLevel = + createAuthRuleRequestCardTokens = authRuleV2CreateParams.createAuthRuleRequestCardTokens + createAuthRuleRequestProgramLevel = authRuleV2CreateParams.createAuthRuleRequestProgramLevel - additionalHeaders(authRuleV2CreateParams.additionalHeaders) - additionalQueryParams(authRuleV2CreateParams.additionalQueryParams) + additionalHeaders = authRuleV2CreateParams.additionalHeaders.toBuilder() + additionalQueryParams = authRuleV2CreateParams.additionalQueryParams.toBuilder() } fun forCreateAuthRuleRequestAccountTokens( @@ -3258,4 +3244,17 @@ constructor( override fun toString() = "CreateAuthRuleRequestProgramLevel{programLevel=$programLevel, type=$type, parameters=$parameters, additionalProperties=$additionalProperties}" } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthRuleV2CreateParams && createAuthRuleRequestAccountTokens == other.createAuthRuleRequestAccountTokens && createAuthRuleRequestCardTokens == other.createAuthRuleRequestCardTokens && createAuthRuleRequestProgramLevel == other.createAuthRuleRequestProgramLevel && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(createAuthRuleRequestAccountTokens, createAuthRuleRequestCardTokens, createAuthRuleRequestProgramLevel, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AuthRuleV2CreateParams{createAuthRuleRequestAccountTokens=$createAuthRuleRequestAccountTokens, createAuthRuleRequestCardTokens=$createAuthRuleRequestCardTokens, createAuthRuleRequestProgramLevel=$createAuthRuleRequestProgramLevel, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2DraftParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2DraftParams.kt index 41944fd1..ea1f344e 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2DraftParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2DraftParams.kt @@ -42,6 +42,12 @@ constructor( fun parameters(): Parameters? = parameters + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): AuthRuleV2DraftBody { return AuthRuleV2DraftBody(parameters, additionalBodyProperties) } @@ -129,25 +135,6 @@ constructor( "AuthRuleV2DraftBody{parameters=$parameters, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthRuleV2DraftParams && authRuleToken == other.authRuleToken && parameters == other.parameters && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, parameters, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AuthRuleV2DraftParams{authRuleToken=$authRuleToken, parameters=$parameters, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -165,11 +152,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(authRuleV2DraftParams: AuthRuleV2DraftParams) = apply { - this.authRuleToken = authRuleV2DraftParams.authRuleToken - this.parameters = authRuleV2DraftParams.parameters - additionalHeaders(authRuleV2DraftParams.additionalHeaders) - additionalQueryParams(authRuleV2DraftParams.additionalQueryParams) - additionalBodyProperties(authRuleV2DraftParams.additionalBodyProperties) + authRuleToken = authRuleV2DraftParams.authRuleToken + parameters = authRuleV2DraftParams.parameters + additionalHeaders = authRuleV2DraftParams.additionalHeaders.toBuilder() + additionalQueryParams = authRuleV2DraftParams.additionalQueryParams.toBuilder() + additionalBodyProperties = authRuleV2DraftParams.additionalBodyProperties.toMutableMap() } fun authRuleToken(authRuleToken: String) = apply { this.authRuleToken = authRuleToken } @@ -1102,4 +1089,17 @@ constructor( "ConditionalBlockParameters{conditions=$conditions, additionalProperties=$additionalProperties}" } } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthRuleV2DraftParams && authRuleToken == other.authRuleToken && parameters == other.parameters && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, parameters, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AuthRuleV2DraftParams{authRuleToken=$authRuleToken, parameters=$parameters, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ListParams.kt index 3903f2cf..0de8362b 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ListParams.kt @@ -29,6 +29,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -42,23 +46,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthRuleV2ListParams && accountToken == other.accountToken && cardToken == other.cardToken && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, cardToken, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AuthRuleV2ListParams{accountToken=$accountToken, cardToken=$cardToken, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -78,13 +65,13 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(authRuleV2ListParams: AuthRuleV2ListParams) = apply { - this.accountToken = authRuleV2ListParams.accountToken - this.cardToken = authRuleV2ListParams.cardToken - this.endingBefore = authRuleV2ListParams.endingBefore - this.pageSize = authRuleV2ListParams.pageSize - this.startingAfter = authRuleV2ListParams.startingAfter - additionalHeaders(authRuleV2ListParams.additionalHeaders) - additionalQueryParams(authRuleV2ListParams.additionalQueryParams) + accountToken = authRuleV2ListParams.accountToken + cardToken = authRuleV2ListParams.cardToken + endingBefore = authRuleV2ListParams.endingBefore + pageSize = authRuleV2ListParams.pageSize + startingAfter = authRuleV2ListParams.startingAfter + additionalHeaders = authRuleV2ListParams.additionalHeaders.toBuilder() + additionalQueryParams = authRuleV2ListParams.additionalQueryParams.toBuilder() } /** Only return Authorization Rules that are bound to the provided account token. */ @@ -217,4 +204,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthRuleV2ListParams && accountToken == other.accountToken && cardToken == other.cardToken && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, cardToken, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AuthRuleV2ListParams{accountToken=$accountToken, cardToken=$cardToken, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2PromoteParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2PromoteParams.kt index 987578ff..1852735f 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2PromoteParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2PromoteParams.kt @@ -20,6 +20,12 @@ constructor( fun authRuleToken(): String = authRuleToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthRuleV2PromoteParams && authRuleToken == other.authRuleToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AuthRuleV2PromoteParams{authRuleToken=$authRuleToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -70,10 +57,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(authRuleV2PromoteParams: AuthRuleV2PromoteParams) = apply { - this.authRuleToken = authRuleV2PromoteParams.authRuleToken - additionalHeaders(authRuleV2PromoteParams.additionalHeaders) - additionalQueryParams(authRuleV2PromoteParams.additionalQueryParams) - additionalBodyProperties(authRuleV2PromoteParams.additionalBodyProperties) + authRuleToken = authRuleV2PromoteParams.authRuleToken + additionalHeaders = authRuleV2PromoteParams.additionalHeaders.toBuilder() + additionalQueryParams = authRuleV2PromoteParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + authRuleV2PromoteParams.additionalBodyProperties.toMutableMap() } fun authRuleToken(authRuleToken: String) = apply { this.authRuleToken = authRuleToken } @@ -206,4 +194,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthRuleV2PromoteParams && authRuleToken == other.authRuleToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AuthRuleV2PromoteParams{authRuleToken=$authRuleToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ReportParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ReportParams.kt index a386770a..61a836ca 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ReportParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2ReportParams.kt @@ -20,6 +20,12 @@ constructor( fun authRuleToken(): String = authRuleToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthRuleV2ReportParams && authRuleToken == other.authRuleToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AuthRuleV2ReportParams{authRuleToken=$authRuleToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -70,10 +57,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(authRuleV2ReportParams: AuthRuleV2ReportParams) = apply { - this.authRuleToken = authRuleV2ReportParams.authRuleToken - additionalHeaders(authRuleV2ReportParams.additionalHeaders) - additionalQueryParams(authRuleV2ReportParams.additionalQueryParams) - additionalBodyProperties(authRuleV2ReportParams.additionalBodyProperties) + authRuleToken = authRuleV2ReportParams.authRuleToken + additionalHeaders = authRuleV2ReportParams.additionalHeaders.toBuilder() + additionalQueryParams = authRuleV2ReportParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + authRuleV2ReportParams.additionalBodyProperties.toMutableMap() } fun authRuleToken(authRuleToken: String) = apply { this.authRuleToken = authRuleToken } @@ -206,4 +194,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthRuleV2ReportParams && authRuleToken == other.authRuleToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AuthRuleV2ReportParams{authRuleToken=$authRuleToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2RetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2RetrieveParams.kt index f8cb0dfb..72f7d95d 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2RetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2RetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun authRuleToken(): String = authRuleToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthRuleV2RetrieveParams && authRuleToken == other.authRuleToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "AuthRuleV2RetrieveParams{authRuleToken=$authRuleToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(authRuleV2RetrieveParams: AuthRuleV2RetrieveParams) = apply { - this.authRuleToken = authRuleV2RetrieveParams.authRuleToken - additionalHeaders(authRuleV2RetrieveParams.additionalHeaders) - additionalQueryParams(authRuleV2RetrieveParams.additionalQueryParams) + authRuleToken = authRuleV2RetrieveParams.authRuleToken + additionalHeaders = authRuleV2RetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = authRuleV2RetrieveParams.additionalQueryParams.toBuilder() } fun authRuleToken(authRuleToken: String) = apply { this.authRuleToken = authRuleToken } @@ -172,4 +159,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthRuleV2RetrieveParams && authRuleToken == other.authRuleToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AuthRuleV2RetrieveParams{authRuleToken=$authRuleToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2UpdateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2UpdateParams.kt index 48cbc6eb..165dd193 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2UpdateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthRuleV2UpdateParams.kt @@ -32,6 +32,12 @@ constructor( fun state(): State? = state + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): AuthRuleV2UpdateBody { return AuthRuleV2UpdateBody(state, additionalBodyProperties) } @@ -130,25 +136,6 @@ constructor( "AuthRuleV2UpdateBody{state=$state, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthRuleV2UpdateParams && authRuleToken == other.authRuleToken && state == other.state && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, state, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "AuthRuleV2UpdateParams{authRuleToken=$authRuleToken, state=$state, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -166,11 +153,12 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(authRuleV2UpdateParams: AuthRuleV2UpdateParams) = apply { - this.authRuleToken = authRuleV2UpdateParams.authRuleToken - this.state = authRuleV2UpdateParams.state - additionalHeaders(authRuleV2UpdateParams.additionalHeaders) - additionalQueryParams(authRuleV2UpdateParams.additionalQueryParams) - additionalBodyProperties(authRuleV2UpdateParams.additionalBodyProperties) + authRuleToken = authRuleV2UpdateParams.authRuleToken + state = authRuleV2UpdateParams.state + additionalHeaders = authRuleV2UpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = authRuleV2UpdateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + authRuleV2UpdateParams.additionalBodyProperties.toMutableMap() } fun authRuleToken(authRuleToken: String) = apply { this.authRuleToken = authRuleToken } @@ -364,4 +352,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthRuleV2UpdateParams && authRuleToken == other.authRuleToken && state == other.state && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(authRuleToken, state, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AuthRuleV2UpdateParams{authRuleToken=$authRuleToken, state=$state, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthStreamEnrollmentRetrieveSecretParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthStreamEnrollmentRetrieveSecretParams.kt index 55bb7d9c..72ed60b2 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthStreamEnrollmentRetrieveSecretParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthStreamEnrollmentRetrieveSecretParams.kt @@ -14,26 +14,13 @@ constructor( private val additionalQueryParams: QueryParams, ) { - internal fun getHeaders(): Headers = additionalHeaders - - internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Headers = additionalHeaders fun _additionalQueryParams(): QueryParams = additionalQueryParams - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthStreamEnrollmentRetrieveSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ + internal fun getHeaders(): Headers = additionalHeaders - override fun toString() = - "AuthStreamEnrollmentRetrieveSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" + internal fun getQueryParams(): QueryParams = additionalQueryParams fun toBuilder() = Builder().from(this) @@ -51,8 +38,10 @@ constructor( internal fun from( authStreamEnrollmentRetrieveSecretParams: AuthStreamEnrollmentRetrieveSecretParams ) = apply { - additionalHeaders(authStreamEnrollmentRetrieveSecretParams.additionalHeaders) - additionalQueryParams(authStreamEnrollmentRetrieveSecretParams.additionalQueryParams) + additionalHeaders = + authStreamEnrollmentRetrieveSecretParams.additionalHeaders.toBuilder() + additionalQueryParams = + authStreamEnrollmentRetrieveSecretParams.additionalQueryParams.toBuilder() } fun additionalHeaders(additionalHeaders: Headers) = apply { @@ -159,4 +148,17 @@ constructor( additionalQueryParams.build() ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthStreamEnrollmentRetrieveSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "AuthStreamEnrollmentRetrieveSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthStreamEnrollmentRotateSecretParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthStreamEnrollmentRotateSecretParams.kt index 16f6f1fa..05cf7665 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthStreamEnrollmentRotateSecretParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/AuthStreamEnrollmentRotateSecretParams.kt @@ -17,32 +17,19 @@ constructor( private val additionalBodyProperties: Map, ) { - internal fun getBody(): Map? { - return additionalBodyProperties.ifEmpty { null } - } - - internal fun getHeaders(): Headers = additionalHeaders - - internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Headers = additionalHeaders fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is AuthStreamEnrollmentRotateSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + internal fun getBody(): Map? { + return additionalBodyProperties.ifEmpty { null } } - override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + internal fun getHeaders(): Headers = additionalHeaders - override fun toString() = - "AuthStreamEnrollmentRotateSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" + internal fun getQueryParams(): QueryParams = additionalQueryParams fun toBuilder() = Builder().from(this) @@ -61,11 +48,11 @@ constructor( internal fun from( authStreamEnrollmentRotateSecretParams: AuthStreamEnrollmentRotateSecretParams ) = apply { - additionalHeaders(authStreamEnrollmentRotateSecretParams.additionalHeaders) - additionalQueryParams(authStreamEnrollmentRotateSecretParams.additionalQueryParams) - additionalBodyProperties( - authStreamEnrollmentRotateSecretParams.additionalBodyProperties - ) + additionalHeaders = authStreamEnrollmentRotateSecretParams.additionalHeaders.toBuilder() + additionalQueryParams = + authStreamEnrollmentRotateSecretParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + authStreamEnrollmentRotateSecretParams.additionalBodyProperties.toMutableMap() } fun additionalHeaders(additionalHeaders: Headers) = apply { @@ -195,4 +182,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is AuthStreamEnrollmentRotateSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "AuthStreamEnrollmentRotateSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BalanceListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BalanceListParams.kt index 043f405f..5a740a6c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BalanceListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BalanceListParams.kt @@ -33,6 +33,10 @@ constructor( fun financialAccountType(): FinancialAccountType? = financialAccountType + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -54,23 +58,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is BalanceListParams && accountToken == other.accountToken && balanceDate == other.balanceDate && businessAccountToken == other.businessAccountToken && financialAccountType == other.financialAccountType && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, balanceDate, businessAccountToken, financialAccountType, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "BalanceListParams{accountToken=$accountToken, balanceDate=$balanceDate, businessAccountToken=$businessAccountToken, financialAccountType=$financialAccountType, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -89,12 +76,12 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(balanceListParams: BalanceListParams) = apply { - this.accountToken = balanceListParams.accountToken - this.balanceDate = balanceListParams.balanceDate - this.businessAccountToken = balanceListParams.businessAccountToken - this.financialAccountType = balanceListParams.financialAccountType - additionalHeaders(balanceListParams.additionalHeaders) - additionalQueryParams(balanceListParams.additionalQueryParams) + accountToken = balanceListParams.accountToken + balanceDate = balanceListParams.balanceDate + businessAccountToken = balanceListParams.businessAccountToken + financialAccountType = balanceListParams.financialAccountType + additionalHeaders = balanceListParams.additionalHeaders.toBuilder() + additionalQueryParams = balanceListParams.additionalQueryParams.toBuilder() } /** List balances for all financial accounts of a given account_token. */ @@ -284,4 +271,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is BalanceListParams && accountToken == other.accountToken && balanceDate == other.balanceDate && businessAccountToken == other.businessAccountToken && financialAccountType == other.financialAccountType && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, balanceDate, businessAccountToken, financialAccountType, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "BalanceListParams{accountToken=$accountToken, balanceDate=$balanceDate, businessAccountToken=$businessAccountToken, financialAccountType=$financialAccountType, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferCreateParams.kt index 2fa17af9..c082cab6 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferCreateParams.kt @@ -50,6 +50,12 @@ constructor( fun memo(): String? = memo + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): BookTransferCreateBody { return BookTransferCreateBody( amount, @@ -249,25 +255,6 @@ constructor( "BookTransferCreateBody{amount=$amount, category=$category, fromFinancialAccountToken=$fromFinancialAccountToken, subtype=$subtype, toFinancialAccountToken=$toFinancialAccountToken, type=$type, token=$token, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is BookTransferCreateParams && amount == other.amount && category == other.category && fromFinancialAccountToken == other.fromFinancialAccountToken && subtype == other.subtype && toFinancialAccountToken == other.toFinancialAccountToken && type == other.type && token == other.token && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, category, fromFinancialAccountToken, subtype, toFinancialAccountToken, type, token, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "BookTransferCreateParams{amount=$amount, category=$category, fromFinancialAccountToken=$fromFinancialAccountToken, subtype=$subtype, toFinancialAccountToken=$toFinancialAccountToken, type=$type, token=$token, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -291,17 +278,18 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(bookTransferCreateParams: BookTransferCreateParams) = apply { - this.amount = bookTransferCreateParams.amount - this.category = bookTransferCreateParams.category - this.fromFinancialAccountToken = bookTransferCreateParams.fromFinancialAccountToken - this.subtype = bookTransferCreateParams.subtype - this.toFinancialAccountToken = bookTransferCreateParams.toFinancialAccountToken - this.type = bookTransferCreateParams.type - this.token = bookTransferCreateParams.token - this.memo = bookTransferCreateParams.memo - additionalHeaders(bookTransferCreateParams.additionalHeaders) - additionalQueryParams(bookTransferCreateParams.additionalQueryParams) - additionalBodyProperties(bookTransferCreateParams.additionalBodyProperties) + amount = bookTransferCreateParams.amount + category = bookTransferCreateParams.category + fromFinancialAccountToken = bookTransferCreateParams.fromFinancialAccountToken + subtype = bookTransferCreateParams.subtype + toFinancialAccountToken = bookTransferCreateParams.toFinancialAccountToken + type = bookTransferCreateParams.type + token = bookTransferCreateParams.token + memo = bookTransferCreateParams.memo + additionalHeaders = bookTransferCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = bookTransferCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + bookTransferCreateParams.additionalBodyProperties.toMutableMap() } /** @@ -807,4 +795,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is BookTransferCreateParams && amount == other.amount && category == other.category && fromFinancialAccountToken == other.fromFinancialAccountToken && subtype == other.subtype && toFinancialAccountToken == other.toFinancialAccountToken && type == other.type && token == other.token && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, category, fromFinancialAccountToken, subtype, toFinancialAccountToken, type, token, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "BookTransferCreateParams{amount=$amount, category=$category, fromFinancialAccountToken=$fromFinancialAccountToken, subtype=$subtype, toFinancialAccountToken=$toFinancialAccountToken, type=$type, token=$token, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferListParams.kt index 12b0a0b9..27c86145 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferListParams.kt @@ -54,6 +54,10 @@ constructor( fun status(): Status? = status + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -81,23 +85,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is BookTransferListParams && accountToken == other.accountToken && begin == other.begin && businessAccountToken == other.businessAccountToken && category == other.category && end == other.end && endingBefore == other.endingBefore && financialAccountToken == other.financialAccountToken && pageSize == other.pageSize && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, businessAccountToken, category, end, endingBefore, financialAccountToken, pageSize, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "BookTransferListParams{accountToken=$accountToken, begin=$begin, businessAccountToken=$businessAccountToken, category=$category, end=$end, endingBefore=$endingBefore, financialAccountToken=$financialAccountToken, pageSize=$pageSize, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -123,19 +110,19 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(bookTransferListParams: BookTransferListParams) = apply { - this.accountToken = bookTransferListParams.accountToken - this.begin = bookTransferListParams.begin - this.businessAccountToken = bookTransferListParams.businessAccountToken - this.category = bookTransferListParams.category - this.end = bookTransferListParams.end - this.endingBefore = bookTransferListParams.endingBefore - this.financialAccountToken = bookTransferListParams.financialAccountToken - this.pageSize = bookTransferListParams.pageSize - this.result = bookTransferListParams.result - this.startingAfter = bookTransferListParams.startingAfter - this.status = bookTransferListParams.status - additionalHeaders(bookTransferListParams.additionalHeaders) - additionalQueryParams(bookTransferListParams.additionalQueryParams) + accountToken = bookTransferListParams.accountToken + begin = bookTransferListParams.begin + businessAccountToken = bookTransferListParams.businessAccountToken + category = bookTransferListParams.category + end = bookTransferListParams.end + endingBefore = bookTransferListParams.endingBefore + financialAccountToken = bookTransferListParams.financialAccountToken + pageSize = bookTransferListParams.pageSize + result = bookTransferListParams.result + startingAfter = bookTransferListParams.startingAfter + status = bookTransferListParams.status + additionalHeaders = bookTransferListParams.additionalHeaders.toBuilder() + additionalQueryParams = bookTransferListParams.additionalQueryParams.toBuilder() } fun accountToken(accountToken: String) = apply { this.accountToken = accountToken } @@ -504,4 +491,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is BookTransferListParams && accountToken == other.accountToken && begin == other.begin && businessAccountToken == other.businessAccountToken && category == other.category && end == other.end && endingBefore == other.endingBefore && financialAccountToken == other.financialAccountToken && pageSize == other.pageSize && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, businessAccountToken, category, end, endingBefore, financialAccountToken, pageSize, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "BookTransferListParams{accountToken=$accountToken, begin=$begin, businessAccountToken=$businessAccountToken, category=$category, end=$end, endingBefore=$endingBefore, financialAccountToken=$financialAccountToken, pageSize=$pageSize, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferRetrieveParams.kt index f9a0ea05..c03b0e04 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun bookTransferToken(): String = bookTransferToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is BookTransferRetrieveParams && bookTransferToken == other.bookTransferToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(bookTransferToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "BookTransferRetrieveParams{bookTransferToken=$bookTransferToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(bookTransferRetrieveParams: BookTransferRetrieveParams) = apply { - this.bookTransferToken = bookTransferRetrieveParams.bookTransferToken - additionalHeaders(bookTransferRetrieveParams.additionalHeaders) - additionalQueryParams(bookTransferRetrieveParams.additionalQueryParams) + bookTransferToken = bookTransferRetrieveParams.bookTransferToken + additionalHeaders = bookTransferRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = bookTransferRetrieveParams.additionalQueryParams.toBuilder() } fun bookTransferToken(bookTransferToken: String) = apply { @@ -176,4 +163,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is BookTransferRetrieveParams && bookTransferToken == other.bookTransferToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(bookTransferToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "BookTransferRetrieveParams{bookTransferToken=$bookTransferToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferReverseParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferReverseParams.kt index b51395c1..9c134293 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferReverseParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/BookTransferReverseParams.kt @@ -28,6 +28,12 @@ constructor( fun memo(): String? = memo + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): BookTransferReverseBody { return BookTransferReverseBody(memo, additionalBodyProperties) } @@ -114,25 +120,6 @@ constructor( "BookTransferReverseBody{memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is BookTransferReverseParams && bookTransferToken == other.bookTransferToken && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(bookTransferToken, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "BookTransferReverseParams{bookTransferToken=$bookTransferToken, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -150,11 +137,12 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(bookTransferReverseParams: BookTransferReverseParams) = apply { - this.bookTransferToken = bookTransferReverseParams.bookTransferToken - this.memo = bookTransferReverseParams.memo - additionalHeaders(bookTransferReverseParams.additionalHeaders) - additionalQueryParams(bookTransferReverseParams.additionalQueryParams) - additionalBodyProperties(bookTransferReverseParams.additionalBodyProperties) + bookTransferToken = bookTransferReverseParams.bookTransferToken + memo = bookTransferReverseParams.memo + additionalHeaders = bookTransferReverseParams.additionalHeaders.toBuilder() + additionalQueryParams = bookTransferReverseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + bookTransferReverseParams.additionalBodyProperties.toMutableMap() } fun bookTransferToken(bookTransferToken: String) = apply { @@ -295,4 +283,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is BookTransferReverseParams && bookTransferToken == other.bookTransferToken && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(bookTransferToken, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "BookTransferReverseParams{bookTransferToken=$bookTransferToken, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardAggregateBalanceListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardAggregateBalanceListParams.kt index ac6d370f..4aad19ad 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardAggregateBalanceListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardAggregateBalanceListParams.kt @@ -20,6 +20,10 @@ constructor( fun businessAccountToken(): String? = businessAccountToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -32,23 +36,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardAggregateBalanceListParams && accountToken == other.accountToken && businessAccountToken == other.businessAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, businessAccountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardAggregateBalanceListParams{accountToken=$accountToken, businessAccountToken=$businessAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -65,10 +52,10 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardAggregateBalanceListParams: CardAggregateBalanceListParams) = apply { - this.accountToken = cardAggregateBalanceListParams.accountToken - this.businessAccountToken = cardAggregateBalanceListParams.businessAccountToken - additionalHeaders(cardAggregateBalanceListParams.additionalHeaders) - additionalQueryParams(cardAggregateBalanceListParams.additionalQueryParams) + accountToken = cardAggregateBalanceListParams.accountToken + businessAccountToken = cardAggregateBalanceListParams.businessAccountToken + additionalHeaders = cardAggregateBalanceListParams.additionalHeaders.toBuilder() + additionalQueryParams = cardAggregateBalanceListParams.additionalQueryParams.toBuilder() } /** Cardholder to retrieve aggregate balances for. */ @@ -185,4 +172,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardAggregateBalanceListParams && accountToken == other.accountToken && businessAccountToken == other.businessAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, businessAccountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardAggregateBalanceListParams{accountToken=$accountToken, businessAccountToken=$businessAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardBalanceListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardBalanceListParams.kt index 26e0f274..61704d8d 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardBalanceListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardBalanceListParams.kt @@ -25,6 +25,10 @@ constructor( fun lastTransactionEventToken(): String? = lastTransactionEventToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -49,23 +53,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardBalanceListParams && cardToken == other.cardToken && balanceDate == other.balanceDate && lastTransactionEventToken == other.lastTransactionEventToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, balanceDate, lastTransactionEventToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardBalanceListParams{cardToken=$cardToken, balanceDate=$balanceDate, lastTransactionEventToken=$lastTransactionEventToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -83,11 +70,11 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardBalanceListParams: CardBalanceListParams) = apply { - this.cardToken = cardBalanceListParams.cardToken - this.balanceDate = cardBalanceListParams.balanceDate - this.lastTransactionEventToken = cardBalanceListParams.lastTransactionEventToken - additionalHeaders(cardBalanceListParams.additionalHeaders) - additionalQueryParams(cardBalanceListParams.additionalQueryParams) + cardToken = cardBalanceListParams.cardToken + balanceDate = cardBalanceListParams.balanceDate + lastTransactionEventToken = cardBalanceListParams.lastTransactionEventToken + additionalHeaders = cardBalanceListParams.additionalHeaders.toBuilder() + additionalQueryParams = cardBalanceListParams.additionalQueryParams.toBuilder() } fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } @@ -210,4 +197,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardBalanceListParams && cardToken == other.cardToken && balanceDate == other.balanceDate && lastTransactionEventToken == other.lastTransactionEventToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, balanceDate, lastTransactionEventToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardBalanceListParams{cardToken=$cardToken, balanceDate=$balanceDate, lastTransactionEventToken=$lastTransactionEventToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardCreateParams.kt index 2a9e7032..42599eb3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardCreateParams.kt @@ -77,6 +77,12 @@ constructor( fun state(): State? = state + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): CardCreateBody { return CardCreateBody( type, @@ -525,25 +531,6 @@ constructor( "CardCreateBody{type=$type, accountToken=$accountToken, cardProgramToken=$cardProgramToken, carrier=$carrier, digitalCardArtToken=$digitalCardArtToken, expMonth=$expMonth, expYear=$expYear, memo=$memo, pin=$pin, productId=$productId, replacementAccountToken=$replacementAccountToken, replacementFor=$replacementFor, shippingAddress=$shippingAddress, shippingMethod=$shippingMethod, spendLimit=$spendLimit, spendLimitDuration=$spendLimitDuration, state=$state, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardCreateParams && type == other.type && accountToken == other.accountToken && cardProgramToken == other.cardProgramToken && carrier == other.carrier && digitalCardArtToken == other.digitalCardArtToken && expMonth == other.expMonth && expYear == other.expYear && memo == other.memo && pin == other.pin && productId == other.productId && replacementAccountToken == other.replacementAccountToken && replacementFor == other.replacementFor && shippingAddress == other.shippingAddress && shippingMethod == other.shippingMethod && spendLimit == other.spendLimit && spendLimitDuration == other.spendLimitDuration && state == other.state && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(type, accountToken, cardProgramToken, carrier, digitalCardArtToken, expMonth, expYear, memo, pin, productId, replacementAccountToken, replacementFor, shippingAddress, shippingMethod, spendLimit, spendLimitDuration, state, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "CardCreateParams{type=$type, accountToken=$accountToken, cardProgramToken=$cardProgramToken, carrier=$carrier, digitalCardArtToken=$digitalCardArtToken, expMonth=$expMonth, expYear=$expYear, memo=$memo, pin=$pin, productId=$productId, replacementAccountToken=$replacementAccountToken, replacementFor=$replacementFor, shippingAddress=$shippingAddress, shippingMethod=$shippingMethod, spendLimit=$spendLimit, spendLimitDuration=$spendLimitDuration, state=$state, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -576,26 +563,26 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardCreateParams: CardCreateParams) = apply { - this.type = cardCreateParams.type - this.accountToken = cardCreateParams.accountToken - this.cardProgramToken = cardCreateParams.cardProgramToken - this.carrier = cardCreateParams.carrier - this.digitalCardArtToken = cardCreateParams.digitalCardArtToken - this.expMonth = cardCreateParams.expMonth - this.expYear = cardCreateParams.expYear - this.memo = cardCreateParams.memo - this.pin = cardCreateParams.pin - this.productId = cardCreateParams.productId - this.replacementAccountToken = cardCreateParams.replacementAccountToken - this.replacementFor = cardCreateParams.replacementFor - this.shippingAddress = cardCreateParams.shippingAddress - this.shippingMethod = cardCreateParams.shippingMethod - this.spendLimit = cardCreateParams.spendLimit - this.spendLimitDuration = cardCreateParams.spendLimitDuration - this.state = cardCreateParams.state - additionalHeaders(cardCreateParams.additionalHeaders) - additionalQueryParams(cardCreateParams.additionalQueryParams) - additionalBodyProperties(cardCreateParams.additionalBodyProperties) + type = cardCreateParams.type + accountToken = cardCreateParams.accountToken + cardProgramToken = cardCreateParams.cardProgramToken + carrier = cardCreateParams.carrier + digitalCardArtToken = cardCreateParams.digitalCardArtToken + expMonth = cardCreateParams.expMonth + expYear = cardCreateParams.expYear + memo = cardCreateParams.memo + pin = cardCreateParams.pin + productId = cardCreateParams.productId + replacementAccountToken = cardCreateParams.replacementAccountToken + replacementFor = cardCreateParams.replacementFor + shippingAddress = cardCreateParams.shippingAddress + shippingMethod = cardCreateParams.shippingMethod + spendLimit = cardCreateParams.spendLimit + spendLimitDuration = cardCreateParams.spendLimitDuration + state = cardCreateParams.state + additionalHeaders = cardCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = cardCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = cardCreateParams.additionalBodyProperties.toMutableMap() } /** @@ -1088,4 +1075,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardCreateParams && type == other.type && accountToken == other.accountToken && cardProgramToken == other.cardProgramToken && carrier == other.carrier && digitalCardArtToken == other.digitalCardArtToken && expMonth == other.expMonth && expYear == other.expYear && memo == other.memo && pin == other.pin && productId == other.productId && replacementAccountToken == other.replacementAccountToken && replacementFor == other.replacementFor && shippingAddress == other.shippingAddress && shippingMethod == other.shippingMethod && spendLimit == other.spendLimit && spendLimitDuration == other.spendLimitDuration && state == other.state && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(type, accountToken, cardProgramToken, carrier, digitalCardArtToken, expMonth, expYear, memo, pin, productId, replacementAccountToken, replacementFor, shippingAddress, shippingMethod, spendLimit, spendLimitDuration, state, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "CardCreateParams{type=$type, accountToken=$accountToken, cardProgramToken=$cardProgramToken, carrier=$carrier, digitalCardArtToken=$digitalCardArtToken, expMonth=$expMonth, expYear=$expYear, memo=$memo, pin=$pin, productId=$productId, replacementAccountToken=$replacementAccountToken, replacementFor=$replacementFor, shippingAddress=$shippingAddress, shippingMethod=$shippingMethod, spendLimit=$spendLimit, spendLimitDuration=$spendLimitDuration, state=$state, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardEmbedParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardEmbedParams.kt index b976676f..e465dc37 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardEmbedParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardEmbedParams.kt @@ -20,6 +20,10 @@ constructor( fun hmac(): String = hmac + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -30,23 +34,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardEmbedParams && embedRequest == other.embedRequest && hmac == other.hmac && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(embedRequest, hmac, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardEmbedParams{embedRequest=$embedRequest, hmac=$hmac, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -63,10 +50,10 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardEmbedParams: CardEmbedParams) = apply { - this.embedRequest = cardEmbedParams.embedRequest - this.hmac = cardEmbedParams.hmac - additionalHeaders(cardEmbedParams.additionalHeaders) - additionalQueryParams(cardEmbedParams.additionalQueryParams) + embedRequest = cardEmbedParams.embedRequest + hmac = cardEmbedParams.hmac + additionalHeaders = cardEmbedParams.additionalHeaders.toBuilder() + additionalQueryParams = cardEmbedParams.additionalQueryParams.toBuilder() } /** A base64 encoded JSON string of an EmbedRequest to specify which card to load. */ @@ -181,4 +168,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardEmbedParams && embedRequest == other.embedRequest && hmac == other.hmac && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(embedRequest, hmac, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardEmbedParams{embedRequest=$embedRequest, hmac=$hmac, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardFinancialTransactionListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardFinancialTransactionListParams.kt index 41b7c1d2..f97b63e4 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardFinancialTransactionListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardFinancialTransactionListParams.kt @@ -45,6 +45,10 @@ constructor( fun status(): Status? = status + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -71,23 +75,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardFinancialTransactionListParams && cardToken == other.cardToken && begin == other.begin && category == other.category && end == other.end && endingBefore == other.endingBefore && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, begin, category, end, endingBefore, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardFinancialTransactionListParams{cardToken=$cardToken, begin=$begin, category=$category, end=$end, endingBefore=$endingBefore, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -111,16 +98,17 @@ constructor( internal fun from(cardFinancialTransactionListParams: CardFinancialTransactionListParams) = apply { - this.cardToken = cardFinancialTransactionListParams.cardToken - this.begin = cardFinancialTransactionListParams.begin - this.category = cardFinancialTransactionListParams.category - this.end = cardFinancialTransactionListParams.end - this.endingBefore = cardFinancialTransactionListParams.endingBefore - this.result = cardFinancialTransactionListParams.result - this.startingAfter = cardFinancialTransactionListParams.startingAfter - this.status = cardFinancialTransactionListParams.status - additionalHeaders(cardFinancialTransactionListParams.additionalHeaders) - additionalQueryParams(cardFinancialTransactionListParams.additionalQueryParams) + cardToken = cardFinancialTransactionListParams.cardToken + begin = cardFinancialTransactionListParams.begin + category = cardFinancialTransactionListParams.category + end = cardFinancialTransactionListParams.end + endingBefore = cardFinancialTransactionListParams.endingBefore + result = cardFinancialTransactionListParams.result + startingAfter = cardFinancialTransactionListParams.startingAfter + status = cardFinancialTransactionListParams.status + additionalHeaders = cardFinancialTransactionListParams.additionalHeaders.toBuilder() + additionalQueryParams = + cardFinancialTransactionListParams.additionalQueryParams.toBuilder() } fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } @@ -465,4 +453,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardFinancialTransactionListParams && cardToken == other.cardToken && begin == other.begin && category == other.category && end == other.end && endingBefore == other.endingBefore && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, begin, category, end, endingBefore, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardFinancialTransactionListParams{cardToken=$cardToken, begin=$begin, category=$category, end=$end, endingBefore=$endingBefore, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardFinancialTransactionRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardFinancialTransactionRetrieveParams.kt index 2ce767de..9608f5d5 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardFinancialTransactionRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardFinancialTransactionRetrieveParams.kt @@ -20,6 +20,10 @@ constructor( fun financialTransactionToken(): String = financialTransactionToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -32,23 +36,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardFinancialTransactionRetrieveParams && cardToken == other.cardToken && financialTransactionToken == other.financialTransactionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, financialTransactionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardFinancialTransactionRetrieveParams{cardToken=$cardToken, financialTransactionToken=$financialTransactionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -67,11 +54,12 @@ constructor( internal fun from( cardFinancialTransactionRetrieveParams: CardFinancialTransactionRetrieveParams ) = apply { - this.cardToken = cardFinancialTransactionRetrieveParams.cardToken - this.financialTransactionToken = + cardToken = cardFinancialTransactionRetrieveParams.cardToken + financialTransactionToken = cardFinancialTransactionRetrieveParams.financialTransactionToken - additionalHeaders(cardFinancialTransactionRetrieveParams.additionalHeaders) - additionalQueryParams(cardFinancialTransactionRetrieveParams.additionalQueryParams) + additionalHeaders = cardFinancialTransactionRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + cardFinancialTransactionRetrieveParams.additionalQueryParams.toBuilder() } fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } @@ -188,4 +176,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardFinancialTransactionRetrieveParams && cardToken == other.cardToken && financialTransactionToken == other.financialTransactionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, financialTransactionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardFinancialTransactionRetrieveParams{cardToken=$cardToken, financialTransactionToken=$financialTransactionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardListParams.kt index b09dbe10..e35a392e 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardListParams.kt @@ -42,6 +42,10 @@ constructor( fun state(): State? = state + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -61,23 +65,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardListParams && accountToken == other.accountToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && state == other.state && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, end, endingBefore, pageSize, startingAfter, state, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardListParams{accountToken=$accountToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, state=$state, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -99,15 +86,15 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardListParams: CardListParams) = apply { - this.accountToken = cardListParams.accountToken - this.begin = cardListParams.begin - this.end = cardListParams.end - this.endingBefore = cardListParams.endingBefore - this.pageSize = cardListParams.pageSize - this.startingAfter = cardListParams.startingAfter - this.state = cardListParams.state - additionalHeaders(cardListParams.additionalHeaders) - additionalQueryParams(cardListParams.additionalQueryParams) + accountToken = cardListParams.accountToken + begin = cardListParams.begin + end = cardListParams.end + endingBefore = cardListParams.endingBefore + pageSize = cardListParams.pageSize + startingAfter = cardListParams.startingAfter + state = cardListParams.state + additionalHeaders = cardListParams.additionalHeaders.toBuilder() + additionalQueryParams = cardListParams.additionalQueryParams.toBuilder() } /** Returns cards associated with the specified account. */ @@ -329,4 +316,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardListParams && accountToken == other.accountToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && state == other.state && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, end, endingBefore, pageSize, startingAfter, state, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardListParams{accountToken=$accountToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, state=$state, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProgramListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProgramListParams.kt index 9cfb4a65..b46187f0 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProgramListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProgramListParams.kt @@ -23,6 +23,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -34,23 +38,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardProgramListParams && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardProgramListParams{endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -68,11 +55,11 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardProgramListParams: CardProgramListParams) = apply { - this.endingBefore = cardProgramListParams.endingBefore - this.pageSize = cardProgramListParams.pageSize - this.startingAfter = cardProgramListParams.startingAfter - additionalHeaders(cardProgramListParams.additionalHeaders) - additionalQueryParams(cardProgramListParams.additionalQueryParams) + endingBefore = cardProgramListParams.endingBefore + pageSize = cardProgramListParams.pageSize + startingAfter = cardProgramListParams.startingAfter + additionalHeaders = cardProgramListParams.additionalHeaders.toBuilder() + additionalQueryParams = cardProgramListParams.additionalQueryParams.toBuilder() } /** @@ -197,4 +184,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardProgramListParams && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardProgramListParams{endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProgramRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProgramRetrieveParams.kt index 0e8a76c6..0a0a68c0 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProgramRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProgramRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun cardProgramToken(): String = cardProgramToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardProgramRetrieveParams && cardProgramToken == other.cardProgramToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardProgramToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardProgramRetrieveParams{cardProgramToken=$cardProgramToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardProgramRetrieveParams: CardProgramRetrieveParams) = apply { - this.cardProgramToken = cardProgramRetrieveParams.cardProgramToken - additionalHeaders(cardProgramRetrieveParams.additionalHeaders) - additionalQueryParams(cardProgramRetrieveParams.additionalQueryParams) + cardProgramToken = cardProgramRetrieveParams.cardProgramToken + additionalHeaders = cardProgramRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = cardProgramRetrieveParams.additionalQueryParams.toBuilder() } fun cardProgramToken(cardProgramToken: String) = apply { @@ -174,4 +161,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardProgramRetrieveParams && cardProgramToken == other.cardProgramToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardProgramToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardProgramRetrieveParams{cardProgramToken=$cardProgramToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProvisionParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProvisionParams.kt index e1dbcf62..713b263a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProvisionParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardProvisionParams.kt @@ -47,6 +47,12 @@ constructor( fun nonceSignature(): String? = nonceSignature + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): CardProvisionBody { return CardProvisionBody( certificate, @@ -244,25 +250,6 @@ constructor( "CardProvisionBody{certificate=$certificate, clientDeviceId=$clientDeviceId, clientWalletAccountId=$clientWalletAccountId, digitalWallet=$digitalWallet, nonce=$nonce, nonceSignature=$nonceSignature, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardProvisionParams && cardToken == other.cardToken && certificate == other.certificate && clientDeviceId == other.clientDeviceId && clientWalletAccountId == other.clientWalletAccountId && digitalWallet == other.digitalWallet && nonce == other.nonce && nonceSignature == other.nonceSignature && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, certificate, clientDeviceId, clientWalletAccountId, digitalWallet, nonce, nonceSignature, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "CardProvisionParams{cardToken=$cardToken, certificate=$certificate, clientDeviceId=$clientDeviceId, clientWalletAccountId=$clientWalletAccountId, digitalWallet=$digitalWallet, nonce=$nonce, nonceSignature=$nonceSignature, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -285,16 +272,16 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardProvisionParams: CardProvisionParams) = apply { - this.cardToken = cardProvisionParams.cardToken - this.certificate = cardProvisionParams.certificate - this.clientDeviceId = cardProvisionParams.clientDeviceId - this.clientWalletAccountId = cardProvisionParams.clientWalletAccountId - this.digitalWallet = cardProvisionParams.digitalWallet - this.nonce = cardProvisionParams.nonce - this.nonceSignature = cardProvisionParams.nonceSignature - additionalHeaders(cardProvisionParams.additionalHeaders) - additionalQueryParams(cardProvisionParams.additionalQueryParams) - additionalBodyProperties(cardProvisionParams.additionalBodyProperties) + cardToken = cardProvisionParams.cardToken + certificate = cardProvisionParams.certificate + clientDeviceId = cardProvisionParams.clientDeviceId + clientWalletAccountId = cardProvisionParams.clientWalletAccountId + digitalWallet = cardProvisionParams.digitalWallet + nonce = cardProvisionParams.nonce + nonceSignature = cardProvisionParams.nonceSignature + additionalHeaders = cardProvisionParams.additionalHeaders.toBuilder() + additionalQueryParams = cardProvisionParams.additionalQueryParams.toBuilder() + additionalBodyProperties = cardProvisionParams.additionalBodyProperties.toMutableMap() } fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } @@ -535,4 +522,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardProvisionParams && cardToken == other.cardToken && certificate == other.certificate && clientDeviceId == other.clientDeviceId && clientWalletAccountId == other.clientWalletAccountId && digitalWallet == other.digitalWallet && nonce == other.nonce && nonceSignature == other.nonceSignature && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, certificate, clientDeviceId, clientWalletAccountId, digitalWallet, nonce, nonceSignature, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "CardProvisionParams{cardToken=$cardToken, certificate=$certificate, clientDeviceId=$clientDeviceId, clientWalletAccountId=$clientWalletAccountId, digitalWallet=$digitalWallet, nonce=$nonce, nonceSignature=$nonceSignature, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardReissueParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardReissueParams.kt index 59f11d0a..2e9c333d 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardReissueParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardReissueParams.kt @@ -41,6 +41,12 @@ constructor( fun shippingMethod(): ShippingMethod? = shippingMethod + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): CardReissueBody { return CardReissueBody( carrier, @@ -203,25 +209,6 @@ constructor( "CardReissueBody{carrier=$carrier, productId=$productId, shippingAddress=$shippingAddress, shippingMethod=$shippingMethod, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardReissueParams && cardToken == other.cardToken && carrier == other.carrier && productId == other.productId && shippingAddress == other.shippingAddress && shippingMethod == other.shippingMethod && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, carrier, productId, shippingAddress, shippingMethod, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "CardReissueParams{cardToken=$cardToken, carrier=$carrier, productId=$productId, shippingAddress=$shippingAddress, shippingMethod=$shippingMethod, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -242,14 +229,14 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardReissueParams: CardReissueParams) = apply { - this.cardToken = cardReissueParams.cardToken - this.carrier = cardReissueParams.carrier - this.productId = cardReissueParams.productId - this.shippingAddress = cardReissueParams.shippingAddress - this.shippingMethod = cardReissueParams.shippingMethod - additionalHeaders(cardReissueParams.additionalHeaders) - additionalQueryParams(cardReissueParams.additionalQueryParams) - additionalBodyProperties(cardReissueParams.additionalBodyProperties) + cardToken = cardReissueParams.cardToken + carrier = cardReissueParams.carrier + productId = cardReissueParams.productId + shippingAddress = cardReissueParams.shippingAddress + shippingMethod = cardReissueParams.shippingMethod + additionalHeaders = cardReissueParams.additionalHeaders.toBuilder() + additionalQueryParams = cardReissueParams.additionalQueryParams.toBuilder() + additionalBodyProperties = cardReissueParams.additionalBodyProperties.toMutableMap() } fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } @@ -497,4 +484,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardReissueParams && cardToken == other.cardToken && carrier == other.carrier && productId == other.productId && shippingAddress == other.shippingAddress && shippingMethod == other.shippingMethod && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, carrier, productId, shippingAddress, shippingMethod, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "CardReissueParams{cardToken=$cardToken, carrier=$carrier, productId=$productId, shippingAddress=$shippingAddress, shippingMethod=$shippingMethod, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRenewParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRenewParams.kt index c8a98882..30a73217 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRenewParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRenewParams.kt @@ -47,6 +47,12 @@ constructor( fun shippingMethod(): ShippingMethod? = shippingMethod + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): CardRenewBody { return CardRenewBody( shippingAddress, @@ -247,25 +253,6 @@ constructor( "CardRenewBody{shippingAddress=$shippingAddress, carrier=$carrier, expMonth=$expMonth, expYear=$expYear, productId=$productId, shippingMethod=$shippingMethod, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardRenewParams && cardToken == other.cardToken && shippingAddress == other.shippingAddress && carrier == other.carrier && expMonth == other.expMonth && expYear == other.expYear && productId == other.productId && shippingMethod == other.shippingMethod && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, shippingAddress, carrier, expMonth, expYear, productId, shippingMethod, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "CardRenewParams{cardToken=$cardToken, shippingAddress=$shippingAddress, carrier=$carrier, expMonth=$expMonth, expYear=$expYear, productId=$productId, shippingMethod=$shippingMethod, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -288,16 +275,16 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardRenewParams: CardRenewParams) = apply { - this.cardToken = cardRenewParams.cardToken - this.shippingAddress = cardRenewParams.shippingAddress - this.carrier = cardRenewParams.carrier - this.expMonth = cardRenewParams.expMonth - this.expYear = cardRenewParams.expYear - this.productId = cardRenewParams.productId - this.shippingMethod = cardRenewParams.shippingMethod - additionalHeaders(cardRenewParams.additionalHeaders) - additionalQueryParams(cardRenewParams.additionalQueryParams) - additionalBodyProperties(cardRenewParams.additionalBodyProperties) + cardToken = cardRenewParams.cardToken + shippingAddress = cardRenewParams.shippingAddress + carrier = cardRenewParams.carrier + expMonth = cardRenewParams.expMonth + expYear = cardRenewParams.expYear + productId = cardRenewParams.productId + shippingMethod = cardRenewParams.shippingMethod + additionalHeaders = cardRenewParams.additionalHeaders.toBuilder() + additionalQueryParams = cardRenewParams.additionalQueryParams.toBuilder() + additionalBodyProperties = cardRenewParams.additionalBodyProperties.toMutableMap() } fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } @@ -559,4 +546,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardRenewParams && cardToken == other.cardToken && shippingAddress == other.shippingAddress && carrier == other.carrier && expMonth == other.expMonth && expYear == other.expYear && productId == other.productId && shippingMethod == other.shippingMethod && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, shippingAddress, carrier, expMonth, expYear, productId, shippingMethod, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "CardRenewParams{cardToken=$cardToken, shippingAddress=$shippingAddress, carrier=$carrier, expMonth=$expMonth, expYear=$expYear, productId=$productId, shippingMethod=$shippingMethod, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRetrieveParams.kt index 9ebf63fb..b281ed13 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun cardToken(): String = cardToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardRetrieveParams && cardToken == other.cardToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardRetrieveParams{cardToken=$cardToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardRetrieveParams: CardRetrieveParams) = apply { - this.cardToken = cardRetrieveParams.cardToken - additionalHeaders(cardRetrieveParams.additionalHeaders) - additionalQueryParams(cardRetrieveParams.additionalQueryParams) + cardToken = cardRetrieveParams.cardToken + additionalHeaders = cardRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = cardRetrieveParams.additionalQueryParams.toBuilder() } fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } @@ -172,4 +159,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardRetrieveParams && cardToken == other.cardToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardRetrieveParams{cardToken=$cardToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRetrieveSpendLimitsParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRetrieveSpendLimitsParams.kt index f087ab91..a9438354 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRetrieveSpendLimitsParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardRetrieveSpendLimitsParams.kt @@ -17,6 +17,10 @@ constructor( fun cardToken(): String = cardToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardRetrieveSpendLimitsParams && cardToken == other.cardToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CardRetrieveSpendLimitsParams{cardToken=$cardToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardRetrieveSpendLimitsParams: CardRetrieveSpendLimitsParams) = apply { - this.cardToken = cardRetrieveSpendLimitsParams.cardToken - additionalHeaders(cardRetrieveSpendLimitsParams.additionalHeaders) - additionalQueryParams(cardRetrieveSpendLimitsParams.additionalQueryParams) + cardToken = cardRetrieveSpendLimitsParams.cardToken + additionalHeaders = cardRetrieveSpendLimitsParams.additionalHeaders.toBuilder() + additionalQueryParams = cardRetrieveSpendLimitsParams.additionalQueryParams.toBuilder() } fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } @@ -172,4 +159,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardRetrieveSpendLimitsParams && cardToken == other.cardToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CardRetrieveSpendLimitsParams{cardToken=$cardToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardSearchByPanParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardSearchByPanParams.kt index 19f1844b..4d63fae1 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardSearchByPanParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardSearchByPanParams.kt @@ -25,6 +25,12 @@ constructor( fun pan(): String = pan + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): CardSearchByPanBody { return CardSearchByPanBody(pan, additionalBodyProperties) } @@ -107,25 +113,6 @@ constructor( "CardSearchByPanBody{pan=$pan, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardSearchByPanParams && pan == other.pan && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(pan, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "CardSearchByPanParams{pan=$pan, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -142,10 +129,10 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardSearchByPanParams: CardSearchByPanParams) = apply { - this.pan = cardSearchByPanParams.pan - additionalHeaders(cardSearchByPanParams.additionalHeaders) - additionalQueryParams(cardSearchByPanParams.additionalQueryParams) - additionalBodyProperties(cardSearchByPanParams.additionalBodyProperties) + pan = cardSearchByPanParams.pan + additionalHeaders = cardSearchByPanParams.additionalHeaders.toBuilder() + additionalQueryParams = cardSearchByPanParams.additionalQueryParams.toBuilder() + additionalBodyProperties = cardSearchByPanParams.additionalBodyProperties.toMutableMap() } /** The PAN for the card being retrieved. */ @@ -279,4 +266,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardSearchByPanParams && pan == other.pan && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(pan, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "CardSearchByPanParams{pan=$pan, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardUpdateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardUpdateParams.kt index 4f3f0f04..5a5829ff 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardUpdateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CardUpdateParams.kt @@ -50,6 +50,12 @@ constructor( fun state(): State? = state + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): CardUpdateBody { return CardUpdateBody( digitalCardArtToken, @@ -287,25 +293,6 @@ constructor( "CardUpdateBody{digitalCardArtToken=$digitalCardArtToken, memo=$memo, pin=$pin, pinStatus=$pinStatus, spendLimit=$spendLimit, spendLimitDuration=$spendLimitDuration, state=$state, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CardUpdateParams && cardToken == other.cardToken && digitalCardArtToken == other.digitalCardArtToken && memo == other.memo && pin == other.pin && pinStatus == other.pinStatus && spendLimit == other.spendLimit && spendLimitDuration == other.spendLimitDuration && state == other.state && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, digitalCardArtToken, memo, pin, pinStatus, spendLimit, spendLimitDuration, state, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "CardUpdateParams{cardToken=$cardToken, digitalCardArtToken=$digitalCardArtToken, memo=$memo, pin=$pin, pinStatus=$pinStatus, spendLimit=$spendLimit, spendLimitDuration=$spendLimitDuration, state=$state, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -329,17 +316,17 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardUpdateParams: CardUpdateParams) = apply { - this.cardToken = cardUpdateParams.cardToken - this.digitalCardArtToken = cardUpdateParams.digitalCardArtToken - this.memo = cardUpdateParams.memo - this.pin = cardUpdateParams.pin - this.pinStatus = cardUpdateParams.pinStatus - this.spendLimit = cardUpdateParams.spendLimit - this.spendLimitDuration = cardUpdateParams.spendLimitDuration - this.state = cardUpdateParams.state - additionalHeaders(cardUpdateParams.additionalHeaders) - additionalQueryParams(cardUpdateParams.additionalQueryParams) - additionalBodyProperties(cardUpdateParams.additionalBodyProperties) + cardToken = cardUpdateParams.cardToken + digitalCardArtToken = cardUpdateParams.digitalCardArtToken + memo = cardUpdateParams.memo + pin = cardUpdateParams.pin + pinStatus = cardUpdateParams.pinStatus + spendLimit = cardUpdateParams.spendLimit + spendLimitDuration = cardUpdateParams.spendLimitDuration + state = cardUpdateParams.state + additionalHeaders = cardUpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = cardUpdateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = cardUpdateParams.additionalBodyProperties.toMutableMap() } fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } @@ -651,4 +638,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CardUpdateParams && cardToken == other.cardToken && digitalCardArtToken == other.digitalCardArtToken && memo == other.memo && pin == other.pin && pinStatus == other.pinStatus && spendLimit == other.spendLimit && spendLimitDuration == other.spendLimitDuration && state == other.state && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cardToken, digitalCardArtToken, memo, pin, pinStatus, spendLimit, spendLimitDuration, state, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "CardUpdateParams{cardToken=$cardToken, digitalCardArtToken=$digitalCardArtToken, memo=$memo, pin=$pin, pinStatus=$pinStatus, spendLimit=$spendLimit, spendLimitDuration=$spendLimitDuration, state=$state, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ClientApiStatusParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ClientApiStatusParams.kt index 8d0667ef..1a658a19 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ClientApiStatusParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ClientApiStatusParams.kt @@ -14,26 +14,13 @@ constructor( private val additionalQueryParams: QueryParams, ) { - internal fun getHeaders(): Headers = additionalHeaders - - internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Headers = additionalHeaders fun _additionalQueryParams(): QueryParams = additionalQueryParams - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ClientApiStatusParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ + internal fun getHeaders(): Headers = additionalHeaders - override fun toString() = - "ClientApiStatusParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" + internal fun getQueryParams(): QueryParams = additionalQueryParams fun toBuilder() = Builder().from(this) @@ -49,8 +36,8 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(clientApiStatusParams: ClientApiStatusParams) = apply { - additionalHeaders(clientApiStatusParams.additionalHeaders) - additionalQueryParams(clientApiStatusParams.additionalQueryParams) + additionalHeaders = clientApiStatusParams.additionalHeaders.toBuilder() + additionalQueryParams = clientApiStatusParams.additionalQueryParams.toBuilder() } fun additionalHeaders(additionalHeaders: Headers) = apply { @@ -154,4 +141,17 @@ constructor( fun build(): ClientApiStatusParams = ClientApiStatusParams(additionalHeaders.build(), additionalQueryParams.build()) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ClientApiStatusParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ClientApiStatusParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductExtendedCreditRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductExtendedCreditRetrieveParams.kt index 99da4d35..ebd4f17a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductExtendedCreditRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductExtendedCreditRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun creditProductToken(): String = creditProductToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CreditProductExtendedCreditRetrieveParams && creditProductToken == other.creditProductToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(creditProductToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CreditProductExtendedCreditRetrieveParams{creditProductToken=$creditProductToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -62,9 +49,11 @@ constructor( internal fun from( creditProductExtendedCreditRetrieveParams: CreditProductExtendedCreditRetrieveParams ) = apply { - this.creditProductToken = creditProductExtendedCreditRetrieveParams.creditProductToken - additionalHeaders(creditProductExtendedCreditRetrieveParams.additionalHeaders) - additionalQueryParams(creditProductExtendedCreditRetrieveParams.additionalQueryParams) + creditProductToken = creditProductExtendedCreditRetrieveParams.creditProductToken + additionalHeaders = + creditProductExtendedCreditRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + creditProductExtendedCreditRetrieveParams.additionalQueryParams.toBuilder() } fun creditProductToken(creditProductToken: String) = apply { @@ -178,4 +167,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CreditProductExtendedCreditRetrieveParams && creditProductToken == other.creditProductToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(creditProductToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CreditProductExtendedCreditRetrieveParams{creditProductToken=$creditProductToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductPrimeRateCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductPrimeRateCreateParams.kt index 097ed087..ad133b39 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductPrimeRateCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductPrimeRateCreateParams.kt @@ -32,6 +32,12 @@ constructor( fun rate(): String = rate + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): CreditProductPrimeRateCreateBody { return CreditProductPrimeRateCreateBody( effectiveDate, @@ -139,25 +145,6 @@ constructor( "CreditProductPrimeRateCreateBody{effectiveDate=$effectiveDate, rate=$rate, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CreditProductPrimeRateCreateParams && creditProductToken == other.creditProductToken && effectiveDate == other.effectiveDate && rate == other.rate && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(creditProductToken, effectiveDate, rate, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "CreditProductPrimeRateCreateParams{creditProductToken=$creditProductToken, effectiveDate=$effectiveDate, rate=$rate, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -177,14 +164,14 @@ constructor( internal fun from(creditProductPrimeRateCreateParams: CreditProductPrimeRateCreateParams) = apply { - this.creditProductToken = creditProductPrimeRateCreateParams.creditProductToken - this.effectiveDate = creditProductPrimeRateCreateParams.effectiveDate - this.rate = creditProductPrimeRateCreateParams.rate - additionalHeaders(creditProductPrimeRateCreateParams.additionalHeaders) - additionalQueryParams(creditProductPrimeRateCreateParams.additionalQueryParams) - additionalBodyProperties( - creditProductPrimeRateCreateParams.additionalBodyProperties - ) + creditProductToken = creditProductPrimeRateCreateParams.creditProductToken + effectiveDate = creditProductPrimeRateCreateParams.effectiveDate + rate = creditProductPrimeRateCreateParams.rate + additionalHeaders = creditProductPrimeRateCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = + creditProductPrimeRateCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + creditProductPrimeRateCreateParams.additionalBodyProperties.toMutableMap() } /** Globally unique identifier for credit products. */ @@ -330,4 +317,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CreditProductPrimeRateCreateParams && creditProductToken == other.creditProductToken && effectiveDate == other.effectiveDate && rate == other.rate && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(creditProductToken, effectiveDate, rate, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "CreditProductPrimeRateCreateParams{creditProductToken=$creditProductToken, effectiveDate=$effectiveDate, rate=$rate, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductPrimeRateRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductPrimeRateRetrieveParams.kt index aaf87be1..9b3739f3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductPrimeRateRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/CreditProductPrimeRateRetrieveParams.kt @@ -24,6 +24,10 @@ constructor( fun startingAfter(): LocalDate? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -41,23 +45,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is CreditProductPrimeRateRetrieveParams && creditProductToken == other.creditProductToken && endingBefore == other.endingBefore && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(creditProductToken, endingBefore, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "CreditProductPrimeRateRetrieveParams{creditProductToken=$creditProductToken, endingBefore=$endingBefore, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -77,11 +64,12 @@ constructor( internal fun from( creditProductPrimeRateRetrieveParams: CreditProductPrimeRateRetrieveParams ) = apply { - this.creditProductToken = creditProductPrimeRateRetrieveParams.creditProductToken - this.endingBefore = creditProductPrimeRateRetrieveParams.endingBefore - this.startingAfter = creditProductPrimeRateRetrieveParams.startingAfter - additionalHeaders(creditProductPrimeRateRetrieveParams.additionalHeaders) - additionalQueryParams(creditProductPrimeRateRetrieveParams.additionalQueryParams) + creditProductToken = creditProductPrimeRateRetrieveParams.creditProductToken + endingBefore = creditProductPrimeRateRetrieveParams.endingBefore + startingAfter = creditProductPrimeRateRetrieveParams.startingAfter + additionalHeaders = creditProductPrimeRateRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + creditProductPrimeRateRetrieveParams.additionalQueryParams.toBuilder() } /** Globally unique identifier for credit products. */ @@ -204,4 +192,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is CreditProductPrimeRateRetrieveParams && creditProductToken == other.creditProductToken && endingBefore == other.endingBefore && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(creditProductToken, endingBefore, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "CreditProductPrimeRateRetrieveParams{creditProductToken=$creditProductToken, endingBefore=$endingBefore, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DigitalCardArtListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DigitalCardArtListParams.kt index 12036a38..0e37f12a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DigitalCardArtListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DigitalCardArtListParams.kt @@ -23,6 +23,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -34,23 +38,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DigitalCardArtListParams && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "DigitalCardArtListParams{endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -68,11 +55,11 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(digitalCardArtListParams: DigitalCardArtListParams) = apply { - this.endingBefore = digitalCardArtListParams.endingBefore - this.pageSize = digitalCardArtListParams.pageSize - this.startingAfter = digitalCardArtListParams.startingAfter - additionalHeaders(digitalCardArtListParams.additionalHeaders) - additionalQueryParams(digitalCardArtListParams.additionalQueryParams) + endingBefore = digitalCardArtListParams.endingBefore + pageSize = digitalCardArtListParams.pageSize + startingAfter = digitalCardArtListParams.startingAfter + additionalHeaders = digitalCardArtListParams.additionalHeaders.toBuilder() + additionalQueryParams = digitalCardArtListParams.additionalQueryParams.toBuilder() } /** @@ -197,4 +184,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DigitalCardArtListParams && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "DigitalCardArtListParams{endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DigitalCardArtRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DigitalCardArtRetrieveParams.kt index fb1f0de5..f2617079 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DigitalCardArtRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DigitalCardArtRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun digitalCardArtToken(): String = digitalCardArtToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DigitalCardArtRetrieveParams && digitalCardArtToken == other.digitalCardArtToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(digitalCardArtToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "DigitalCardArtRetrieveParams{digitalCardArtToken=$digitalCardArtToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(digitalCardArtRetrieveParams: DigitalCardArtRetrieveParams) = apply { - this.digitalCardArtToken = digitalCardArtRetrieveParams.digitalCardArtToken - additionalHeaders(digitalCardArtRetrieveParams.additionalHeaders) - additionalQueryParams(digitalCardArtRetrieveParams.additionalQueryParams) + digitalCardArtToken = digitalCardArtRetrieveParams.digitalCardArtToken + additionalHeaders = digitalCardArtRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = digitalCardArtRetrieveParams.additionalQueryParams.toBuilder() } fun digitalCardArtToken(digitalCardArtToken: String) = apply { @@ -176,4 +163,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DigitalCardArtRetrieveParams && digitalCardArtToken == other.digitalCardArtToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(digitalCardArtToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "DigitalCardArtRetrieveParams{digitalCardArtToken=$digitalCardArtToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeCreateParams.kt index 6ecc814d..c6a8b808 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeCreateParams.kt @@ -42,6 +42,12 @@ constructor( fun customerNote(): String? = customerNote + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): DisputeCreateBody { return DisputeCreateBody( amount, @@ -181,25 +187,6 @@ constructor( "DisputeCreateBody{amount=$amount, reason=$reason, transactionToken=$transactionToken, customerFiledDate=$customerFiledDate, customerNote=$customerNote, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DisputeCreateParams && amount == other.amount && reason == other.reason && transactionToken == other.transactionToken && customerFiledDate == other.customerFiledDate && customerNote == other.customerNote && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, reason, transactionToken, customerFiledDate, customerNote, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "DisputeCreateParams{amount=$amount, reason=$reason, transactionToken=$transactionToken, customerFiledDate=$customerFiledDate, customerNote=$customerNote, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -220,14 +207,14 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(disputeCreateParams: DisputeCreateParams) = apply { - this.amount = disputeCreateParams.amount - this.reason = disputeCreateParams.reason - this.transactionToken = disputeCreateParams.transactionToken - this.customerFiledDate = disputeCreateParams.customerFiledDate - this.customerNote = disputeCreateParams.customerNote - additionalHeaders(disputeCreateParams.additionalHeaders) - additionalQueryParams(disputeCreateParams.additionalQueryParams) - additionalBodyProperties(disputeCreateParams.additionalBodyProperties) + amount = disputeCreateParams.amount + reason = disputeCreateParams.reason + transactionToken = disputeCreateParams.transactionToken + customerFiledDate = disputeCreateParams.customerFiledDate + customerNote = disputeCreateParams.customerNote + additionalHeaders = disputeCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = disputeCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = disputeCreateParams.additionalBodyProperties.toMutableMap() } /** Amount to dispute */ @@ -512,4 +499,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DisputeCreateParams && amount == other.amount && reason == other.reason && transactionToken == other.transactionToken && customerFiledDate == other.customerFiledDate && customerNote == other.customerNote && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, reason, transactionToken, customerFiledDate, customerNote, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "DisputeCreateParams{amount=$amount, reason=$reason, transactionToken=$transactionToken, customerFiledDate=$customerFiledDate, customerNote=$customerNote, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeDeleteEvidenceParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeDeleteEvidenceParams.kt index 19a7d94d..1eafac74 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeDeleteEvidenceParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeDeleteEvidenceParams.kt @@ -23,6 +23,12 @@ constructor( fun evidenceToken(): String = evidenceToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -39,25 +45,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DisputeDeleteEvidenceParams && disputeToken == other.disputeToken && evidenceToken == other.evidenceToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, evidenceToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "DisputeDeleteEvidenceParams{disputeToken=$disputeToken, evidenceToken=$evidenceToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -75,11 +62,12 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(disputeDeleteEvidenceParams: DisputeDeleteEvidenceParams) = apply { - this.disputeToken = disputeDeleteEvidenceParams.disputeToken - this.evidenceToken = disputeDeleteEvidenceParams.evidenceToken - additionalHeaders(disputeDeleteEvidenceParams.additionalHeaders) - additionalQueryParams(disputeDeleteEvidenceParams.additionalQueryParams) - additionalBodyProperties(disputeDeleteEvidenceParams.additionalBodyProperties) + disputeToken = disputeDeleteEvidenceParams.disputeToken + evidenceToken = disputeDeleteEvidenceParams.evidenceToken + additionalHeaders = disputeDeleteEvidenceParams.additionalHeaders.toBuilder() + additionalQueryParams = disputeDeleteEvidenceParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + disputeDeleteEvidenceParams.additionalBodyProperties.toMutableMap() } fun disputeToken(disputeToken: String) = apply { this.disputeToken = disputeToken } @@ -215,4 +203,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DisputeDeleteEvidenceParams && disputeToken == other.disputeToken && evidenceToken == other.evidenceToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, evidenceToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "DisputeDeleteEvidenceParams{disputeToken=$disputeToken, evidenceToken=$evidenceToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeDeleteParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeDeleteParams.kt index 6b154805..6e4aae87 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeDeleteParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeDeleteParams.kt @@ -20,6 +20,12 @@ constructor( fun disputeToken(): String = disputeToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DisputeDeleteParams && disputeToken == other.disputeToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "DisputeDeleteParams{disputeToken=$disputeToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -70,10 +57,10 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(disputeDeleteParams: DisputeDeleteParams) = apply { - this.disputeToken = disputeDeleteParams.disputeToken - additionalHeaders(disputeDeleteParams.additionalHeaders) - additionalQueryParams(disputeDeleteParams.additionalQueryParams) - additionalBodyProperties(disputeDeleteParams.additionalBodyProperties) + disputeToken = disputeDeleteParams.disputeToken + additionalHeaders = disputeDeleteParams.additionalHeaders.toBuilder() + additionalQueryParams = disputeDeleteParams.additionalQueryParams.toBuilder() + additionalBodyProperties = disputeDeleteParams.additionalBodyProperties.toMutableMap() } fun disputeToken(disputeToken: String) = apply { this.disputeToken = disputeToken } @@ -206,4 +193,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DisputeDeleteParams && disputeToken == other.disputeToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "DisputeDeleteParams{disputeToken=$disputeToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeInitiateEvidenceUploadParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeInitiateEvidenceUploadParams.kt index 8bff753b..ca0de9b4 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeInitiateEvidenceUploadParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeInitiateEvidenceUploadParams.kt @@ -28,6 +28,12 @@ constructor( fun filename(): String? = filename + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): DisputeInitiateEvidenceUploadBody { return DisputeInitiateEvidenceUploadBody(filename, additionalBodyProperties) } @@ -117,25 +123,6 @@ constructor( "DisputeInitiateEvidenceUploadBody{filename=$filename, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DisputeInitiateEvidenceUploadParams && disputeToken == other.disputeToken && filename == other.filename && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, filename, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "DisputeInitiateEvidenceUploadParams{disputeToken=$disputeToken, filename=$filename, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -155,11 +142,13 @@ constructor( internal fun from( disputeInitiateEvidenceUploadParams: DisputeInitiateEvidenceUploadParams ) = apply { - this.disputeToken = disputeInitiateEvidenceUploadParams.disputeToken - this.filename = disputeInitiateEvidenceUploadParams.filename - additionalHeaders(disputeInitiateEvidenceUploadParams.additionalHeaders) - additionalQueryParams(disputeInitiateEvidenceUploadParams.additionalQueryParams) - additionalBodyProperties(disputeInitiateEvidenceUploadParams.additionalBodyProperties) + disputeToken = disputeInitiateEvidenceUploadParams.disputeToken + filename = disputeInitiateEvidenceUploadParams.filename + additionalHeaders = disputeInitiateEvidenceUploadParams.additionalHeaders.toBuilder() + additionalQueryParams = + disputeInitiateEvidenceUploadParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + disputeInitiateEvidenceUploadParams.additionalBodyProperties.toMutableMap() } fun disputeToken(disputeToken: String) = apply { this.disputeToken = disputeToken } @@ -296,4 +285,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DisputeInitiateEvidenceUploadParams && disputeToken == other.disputeToken && filename == other.filename && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, filename, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "DisputeInitiateEvidenceUploadParams{disputeToken=$disputeToken, filename=$filename, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeListEvidencesParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeListEvidencesParams.kt index b2dfe54d..643c9866 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeListEvidencesParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeListEvidencesParams.kt @@ -34,6 +34,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -58,23 +62,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DisputeListEvidencesParams && disputeToken == other.disputeToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, begin, end, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "DisputeListEvidencesParams{disputeToken=$disputeToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -95,14 +82,14 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(disputeListEvidencesParams: DisputeListEvidencesParams) = apply { - this.disputeToken = disputeListEvidencesParams.disputeToken - this.begin = disputeListEvidencesParams.begin - this.end = disputeListEvidencesParams.end - this.endingBefore = disputeListEvidencesParams.endingBefore - this.pageSize = disputeListEvidencesParams.pageSize - this.startingAfter = disputeListEvidencesParams.startingAfter - additionalHeaders(disputeListEvidencesParams.additionalHeaders) - additionalQueryParams(disputeListEvidencesParams.additionalQueryParams) + disputeToken = disputeListEvidencesParams.disputeToken + begin = disputeListEvidencesParams.begin + end = disputeListEvidencesParams.end + endingBefore = disputeListEvidencesParams.endingBefore + pageSize = disputeListEvidencesParams.pageSize + startingAfter = disputeListEvidencesParams.startingAfter + additionalHeaders = disputeListEvidencesParams.additionalHeaders.toBuilder() + additionalQueryParams = disputeListEvidencesParams.additionalQueryParams.toBuilder() } fun disputeToken(disputeToken: String) = apply { this.disputeToken = disputeToken } @@ -244,4 +231,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DisputeListEvidencesParams && disputeToken == other.disputeToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, begin, end, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "DisputeListEvidencesParams{disputeToken=$disputeToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeListParams.kt index 2f70b606..ff9eb5cd 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeListParams.kt @@ -43,6 +43,10 @@ constructor( fun transactionTokens(): List? = transactionTokens + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -64,23 +68,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DisputeListParams && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && status == other.status && transactionTokens == other.transactionTokens && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, end, endingBefore, pageSize, startingAfter, status, transactionTokens, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "DisputeListParams{begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, status=$status, transactionTokens=$transactionTokens, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -102,15 +89,16 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(disputeListParams: DisputeListParams) = apply { - this.begin = disputeListParams.begin - this.end = disputeListParams.end - this.endingBefore = disputeListParams.endingBefore - this.pageSize = disputeListParams.pageSize - this.startingAfter = disputeListParams.startingAfter - this.status = disputeListParams.status - this.transactionTokens(disputeListParams.transactionTokens ?: listOf()) - additionalHeaders(disputeListParams.additionalHeaders) - additionalQueryParams(disputeListParams.additionalQueryParams) + begin = disputeListParams.begin + end = disputeListParams.end + endingBefore = disputeListParams.endingBefore + pageSize = disputeListParams.pageSize + startingAfter = disputeListParams.startingAfter + status = disputeListParams.status + transactionTokens = + disputeListParams.transactionTokens?.toMutableList() ?: mutableListOf() + additionalHeaders = disputeListParams.additionalHeaders.toBuilder() + additionalQueryParams = disputeListParams.additionalQueryParams.toBuilder() } /** @@ -260,7 +248,7 @@ constructor( pageSize, startingAfter, status, - if (transactionTokens.size == 0) null else transactionTokens.toImmutable(), + transactionTokens.toImmutable().ifEmpty { null }, additionalHeaders.build(), additionalQueryParams.build(), ) @@ -358,4 +346,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DisputeListParams && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && status == other.status && transactionTokens == other.transactionTokens && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, end, endingBefore, pageSize, startingAfter, status, transactionTokens, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "DisputeListParams{begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, status=$status, transactionTokens=$transactionTokens, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeRetrieveEvidenceParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeRetrieveEvidenceParams.kt index d380fd1e..eb679cc3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeRetrieveEvidenceParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeRetrieveEvidenceParams.kt @@ -20,6 +20,10 @@ constructor( fun evidenceToken(): String = evidenceToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -32,23 +36,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DisputeRetrieveEvidenceParams && disputeToken == other.disputeToken && evidenceToken == other.evidenceToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, evidenceToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "DisputeRetrieveEvidenceParams{disputeToken=$disputeToken, evidenceToken=$evidenceToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -65,10 +52,10 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(disputeRetrieveEvidenceParams: DisputeRetrieveEvidenceParams) = apply { - this.disputeToken = disputeRetrieveEvidenceParams.disputeToken - this.evidenceToken = disputeRetrieveEvidenceParams.evidenceToken - additionalHeaders(disputeRetrieveEvidenceParams.additionalHeaders) - additionalQueryParams(disputeRetrieveEvidenceParams.additionalQueryParams) + disputeToken = disputeRetrieveEvidenceParams.disputeToken + evidenceToken = disputeRetrieveEvidenceParams.evidenceToken + additionalHeaders = disputeRetrieveEvidenceParams.additionalHeaders.toBuilder() + additionalQueryParams = disputeRetrieveEvidenceParams.additionalQueryParams.toBuilder() } fun disputeToken(disputeToken: String) = apply { this.disputeToken = disputeToken } @@ -181,4 +168,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DisputeRetrieveEvidenceParams && disputeToken == other.disputeToken && evidenceToken == other.evidenceToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, evidenceToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "DisputeRetrieveEvidenceParams{disputeToken=$disputeToken, evidenceToken=$evidenceToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeRetrieveParams.kt index 811085dd..9f970615 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun disputeToken(): String = disputeToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DisputeRetrieveParams && disputeToken == other.disputeToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "DisputeRetrieveParams{disputeToken=$disputeToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(disputeRetrieveParams: DisputeRetrieveParams) = apply { - this.disputeToken = disputeRetrieveParams.disputeToken - additionalHeaders(disputeRetrieveParams.additionalHeaders) - additionalQueryParams(disputeRetrieveParams.additionalQueryParams) + disputeToken = disputeRetrieveParams.disputeToken + additionalHeaders = disputeRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = disputeRetrieveParams.additionalQueryParams.toBuilder() } fun disputeToken(disputeToken: String) = apply { this.disputeToken = disputeToken } @@ -172,4 +159,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DisputeRetrieveParams && disputeToken == other.disputeToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "DisputeRetrieveParams{disputeToken=$disputeToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeUpdateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeUpdateParams.kt index d4c72b8a..296d9884 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeUpdateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/DisputeUpdateParams.kt @@ -42,6 +42,12 @@ constructor( fun reason(): Reason? = reason + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): DisputeUpdateBody { return DisputeUpdateBody( amount, @@ -172,25 +178,6 @@ constructor( "DisputeUpdateBody{amount=$amount, customerFiledDate=$customerFiledDate, customerNote=$customerNote, reason=$reason, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is DisputeUpdateParams && disputeToken == other.disputeToken && amount == other.amount && customerFiledDate == other.customerFiledDate && customerNote == other.customerNote && reason == other.reason && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, amount, customerFiledDate, customerNote, reason, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "DisputeUpdateParams{disputeToken=$disputeToken, amount=$amount, customerFiledDate=$customerFiledDate, customerNote=$customerNote, reason=$reason, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -211,14 +198,14 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(disputeUpdateParams: DisputeUpdateParams) = apply { - this.disputeToken = disputeUpdateParams.disputeToken - this.amount = disputeUpdateParams.amount - this.customerFiledDate = disputeUpdateParams.customerFiledDate - this.customerNote = disputeUpdateParams.customerNote - this.reason = disputeUpdateParams.reason - additionalHeaders(disputeUpdateParams.additionalHeaders) - additionalQueryParams(disputeUpdateParams.additionalQueryParams) - additionalBodyProperties(disputeUpdateParams.additionalBodyProperties) + disputeToken = disputeUpdateParams.disputeToken + amount = disputeUpdateParams.amount + customerFiledDate = disputeUpdateParams.customerFiledDate + customerNote = disputeUpdateParams.customerNote + reason = disputeUpdateParams.reason + additionalHeaders = disputeUpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = disputeUpdateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = disputeUpdateParams.additionalBodyProperties.toMutableMap() } fun disputeToken(disputeToken: String) = apply { this.disputeToken = disputeToken } @@ -500,4 +487,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is DisputeUpdateParams && disputeToken == other.disputeToken && amount == other.amount && customerFiledDate == other.customerFiledDate && customerNote == other.customerNote && reason == other.reason && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(disputeToken, amount, customerFiledDate, customerNote, reason, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "DisputeUpdateParams{disputeToken=$disputeToken, amount=$amount, customerFiledDate=$customerFiledDate, customerNote=$customerNote, reason=$reason, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventListAttemptsParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventListAttemptsParams.kt index 270b9e8e..d0d5bdd7 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventListAttemptsParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventListAttemptsParams.kt @@ -42,6 +42,10 @@ constructor( fun status(): Status? = status + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -67,23 +71,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventListAttemptsParams && eventToken == other.eventToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventToken, begin, end, endingBefore, pageSize, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "EventListAttemptsParams{eventToken=$eventToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -105,15 +92,15 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(eventListAttemptsParams: EventListAttemptsParams) = apply { - this.eventToken = eventListAttemptsParams.eventToken - this.begin = eventListAttemptsParams.begin - this.end = eventListAttemptsParams.end - this.endingBefore = eventListAttemptsParams.endingBefore - this.pageSize = eventListAttemptsParams.pageSize - this.startingAfter = eventListAttemptsParams.startingAfter - this.status = eventListAttemptsParams.status - additionalHeaders(eventListAttemptsParams.additionalHeaders) - additionalQueryParams(eventListAttemptsParams.additionalQueryParams) + eventToken = eventListAttemptsParams.eventToken + begin = eventListAttemptsParams.begin + end = eventListAttemptsParams.end + endingBefore = eventListAttemptsParams.endingBefore + pageSize = eventListAttemptsParams.pageSize + startingAfter = eventListAttemptsParams.startingAfter + status = eventListAttemptsParams.status + additionalHeaders = eventListAttemptsParams.additionalHeaders.toBuilder() + additionalQueryParams = eventListAttemptsParams.additionalQueryParams.toBuilder() } fun eventToken(eventToken: String) = apply { this.eventToken = eventToken } @@ -327,4 +314,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventListAttemptsParams && eventToken == other.eventToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventToken, begin, end, endingBefore, pageSize, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "EventListAttemptsParams{eventToken=$eventToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventListParams.kt index 38d6a77e..8ac7d809 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventListParams.kt @@ -43,6 +43,10 @@ constructor( fun withContent(): Boolean? = withContent + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -64,23 +68,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventListParams && begin == other.begin && end == other.end && endingBefore == other.endingBefore && eventTypes == other.eventTypes && pageSize == other.pageSize && startingAfter == other.startingAfter && withContent == other.withContent && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, end, endingBefore, eventTypes, pageSize, startingAfter, withContent, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "EventListParams{begin=$begin, end=$end, endingBefore=$endingBefore, eventTypes=$eventTypes, pageSize=$pageSize, startingAfter=$startingAfter, withContent=$withContent, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -102,15 +89,15 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(eventListParams: EventListParams) = apply { - this.begin = eventListParams.begin - this.end = eventListParams.end - this.endingBefore = eventListParams.endingBefore - this.eventTypes(eventListParams.eventTypes ?: listOf()) - this.pageSize = eventListParams.pageSize - this.startingAfter = eventListParams.startingAfter - this.withContent = eventListParams.withContent - additionalHeaders(eventListParams.additionalHeaders) - additionalQueryParams(eventListParams.additionalQueryParams) + begin = eventListParams.begin + end = eventListParams.end + endingBefore = eventListParams.endingBefore + eventTypes = eventListParams.eventTypes?.toMutableList() ?: mutableListOf() + pageSize = eventListParams.pageSize + startingAfter = eventListParams.startingAfter + withContent = eventListParams.withContent + additionalHeaders = eventListParams.additionalHeaders.toBuilder() + additionalQueryParams = eventListParams.additionalQueryParams.toBuilder() } /** @@ -255,7 +242,7 @@ constructor( begin, end, endingBefore, - if (eventTypes.size == 0) null else eventTypes.toImmutable(), + eventTypes.toImmutable().ifEmpty { null }, pageSize, startingAfter, withContent, @@ -566,4 +553,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventListParams && begin == other.begin && end == other.end && endingBefore == other.endingBefore && eventTypes == other.eventTypes && pageSize == other.pageSize && startingAfter == other.startingAfter && withContent == other.withContent && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, end, endingBefore, eventTypes, pageSize, startingAfter, withContent, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "EventListParams{begin=$begin, end=$end, endingBefore=$endingBefore, eventTypes=$eventTypes, pageSize=$pageSize, startingAfter=$startingAfter, withContent=$withContent, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventRetrieveParams.kt index 1f2b8d9c..c59682fd 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun eventToken(): String = eventToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventRetrieveParams && eventToken == other.eventToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "EventRetrieveParams{eventToken=$eventToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(eventRetrieveParams: EventRetrieveParams) = apply { - this.eventToken = eventRetrieveParams.eventToken - additionalHeaders(eventRetrieveParams.additionalHeaders) - additionalQueryParams(eventRetrieveParams.additionalQueryParams) + eventToken = eventRetrieveParams.eventToken + additionalHeaders = eventRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = eventRetrieveParams.additionalQueryParams.toBuilder() } fun eventToken(eventToken: String) = apply { this.eventToken = eventToken } @@ -172,4 +159,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventRetrieveParams && eventToken == other.eventToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "EventRetrieveParams{eventToken=$eventToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionCreateParams.kt index ae4bf0d3..002e1e22 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionCreateParams.kt @@ -38,6 +38,12 @@ constructor( fun eventTypes(): List? = eventTypes + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): EventSubscriptionCreateBody { return EventSubscriptionCreateBody( url, @@ -165,25 +171,6 @@ constructor( "EventSubscriptionCreateBody{url=$url, description=$description, disabled=$disabled, eventTypes=$eventTypes, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionCreateParams && url == other.url && description == other.description && disabled == other.disabled && eventTypes == other.eventTypes && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(url, description, disabled, eventTypes, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "EventSubscriptionCreateParams{url=$url, description=$description, disabled=$disabled, eventTypes=$eventTypes, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -203,13 +190,15 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(eventSubscriptionCreateParams: EventSubscriptionCreateParams) = apply { - this.url = eventSubscriptionCreateParams.url - this.description = eventSubscriptionCreateParams.description - this.disabled = eventSubscriptionCreateParams.disabled - this.eventTypes(eventSubscriptionCreateParams.eventTypes ?: listOf()) - additionalHeaders(eventSubscriptionCreateParams.additionalHeaders) - additionalQueryParams(eventSubscriptionCreateParams.additionalQueryParams) - additionalBodyProperties(eventSubscriptionCreateParams.additionalBodyProperties) + url = eventSubscriptionCreateParams.url + description = eventSubscriptionCreateParams.description + disabled = eventSubscriptionCreateParams.disabled + eventTypes = + eventSubscriptionCreateParams.eventTypes?.toMutableList() ?: mutableListOf() + additionalHeaders = eventSubscriptionCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = eventSubscriptionCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + eventSubscriptionCreateParams.additionalBodyProperties.toMutableMap() } /** URL to which event webhooks will be sent. URL must be a valid HTTPS address. */ @@ -361,7 +350,7 @@ constructor( checkNotNull(url) { "`url` is required but was not set" }, description, disabled, - if (eventTypes.size == 0) null else eventTypes.toImmutable(), + eventTypes.toImmutable().ifEmpty { null }, additionalHeaders.build(), additionalQueryParams.build(), additionalBodyProperties.toImmutable(), @@ -670,4 +659,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionCreateParams && url == other.url && description == other.description && disabled == other.disabled && eventTypes == other.eventTypes && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(url, description, disabled, eventTypes, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "EventSubscriptionCreateParams{url=$url, description=$description, disabled=$disabled, eventTypes=$eventTypes, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionDeleteParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionDeleteParams.kt index 921974e5..2b274743 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionDeleteParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionDeleteParams.kt @@ -20,6 +20,12 @@ constructor( fun eventSubscriptionToken(): String = eventSubscriptionToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionDeleteParams && eventSubscriptionToken == other.eventSubscriptionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "EventSubscriptionDeleteParams{eventSubscriptionToken=$eventSubscriptionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -70,10 +57,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(eventSubscriptionDeleteParams: EventSubscriptionDeleteParams) = apply { - this.eventSubscriptionToken = eventSubscriptionDeleteParams.eventSubscriptionToken - additionalHeaders(eventSubscriptionDeleteParams.additionalHeaders) - additionalQueryParams(eventSubscriptionDeleteParams.additionalQueryParams) - additionalBodyProperties(eventSubscriptionDeleteParams.additionalBodyProperties) + eventSubscriptionToken = eventSubscriptionDeleteParams.eventSubscriptionToken + additionalHeaders = eventSubscriptionDeleteParams.additionalHeaders.toBuilder() + additionalQueryParams = eventSubscriptionDeleteParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + eventSubscriptionDeleteParams.additionalBodyProperties.toMutableMap() } fun eventSubscriptionToken(eventSubscriptionToken: String) = apply { @@ -210,4 +198,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionDeleteParams && eventSubscriptionToken == other.eventSubscriptionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "EventSubscriptionDeleteParams{eventSubscriptionToken=$eventSubscriptionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionListAttemptsParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionListAttemptsParams.kt index bd49f755..2fc0658e 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionListAttemptsParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionListAttemptsParams.kt @@ -42,6 +42,10 @@ constructor( fun status(): Status? = status + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -67,23 +71,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionListAttemptsParams && eventSubscriptionToken == other.eventSubscriptionToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, begin, end, endingBefore, pageSize, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "EventSubscriptionListAttemptsParams{eventSubscriptionToken=$eventSubscriptionToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -107,15 +94,16 @@ constructor( internal fun from( eventSubscriptionListAttemptsParams: EventSubscriptionListAttemptsParams ) = apply { - this.eventSubscriptionToken = eventSubscriptionListAttemptsParams.eventSubscriptionToken - this.begin = eventSubscriptionListAttemptsParams.begin - this.end = eventSubscriptionListAttemptsParams.end - this.endingBefore = eventSubscriptionListAttemptsParams.endingBefore - this.pageSize = eventSubscriptionListAttemptsParams.pageSize - this.startingAfter = eventSubscriptionListAttemptsParams.startingAfter - this.status = eventSubscriptionListAttemptsParams.status - additionalHeaders(eventSubscriptionListAttemptsParams.additionalHeaders) - additionalQueryParams(eventSubscriptionListAttemptsParams.additionalQueryParams) + eventSubscriptionToken = eventSubscriptionListAttemptsParams.eventSubscriptionToken + begin = eventSubscriptionListAttemptsParams.begin + end = eventSubscriptionListAttemptsParams.end + endingBefore = eventSubscriptionListAttemptsParams.endingBefore + pageSize = eventSubscriptionListAttemptsParams.pageSize + startingAfter = eventSubscriptionListAttemptsParams.startingAfter + status = eventSubscriptionListAttemptsParams.status + additionalHeaders = eventSubscriptionListAttemptsParams.additionalHeaders.toBuilder() + additionalQueryParams = + eventSubscriptionListAttemptsParams.additionalQueryParams.toBuilder() } fun eventSubscriptionToken(eventSubscriptionToken: String) = apply { @@ -333,4 +321,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionListAttemptsParams && eventSubscriptionToken == other.eventSubscriptionToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, begin, end, endingBefore, pageSize, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "EventSubscriptionListAttemptsParams{eventSubscriptionToken=$eventSubscriptionToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionListParams.kt index 17b87479..8c972b58 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionListParams.kt @@ -23,6 +23,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -34,23 +38,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionListParams && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "EventSubscriptionListParams{endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -68,11 +55,11 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(eventSubscriptionListParams: EventSubscriptionListParams) = apply { - this.endingBefore = eventSubscriptionListParams.endingBefore - this.pageSize = eventSubscriptionListParams.pageSize - this.startingAfter = eventSubscriptionListParams.startingAfter - additionalHeaders(eventSubscriptionListParams.additionalHeaders) - additionalQueryParams(eventSubscriptionListParams.additionalQueryParams) + endingBefore = eventSubscriptionListParams.endingBefore + pageSize = eventSubscriptionListParams.pageSize + startingAfter = eventSubscriptionListParams.startingAfter + additionalHeaders = eventSubscriptionListParams.additionalHeaders.toBuilder() + additionalQueryParams = eventSubscriptionListParams.additionalQueryParams.toBuilder() } /** @@ -197,4 +184,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionListParams && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "EventSubscriptionListParams{endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRecoverParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRecoverParams.kt index 525e21fc..97f7755c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRecoverParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRecoverParams.kt @@ -28,6 +28,12 @@ constructor( fun end(): OffsetDateTime? = end + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -53,25 +59,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionRecoverParams && eventSubscriptionToken == other.eventSubscriptionToken && begin == other.begin && end == other.end && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, begin, end, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "EventSubscriptionRecoverParams{eventSubscriptionToken=$eventSubscriptionToken, begin=$begin, end=$end, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -90,12 +77,13 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(eventSubscriptionRecoverParams: EventSubscriptionRecoverParams) = apply { - this.eventSubscriptionToken = eventSubscriptionRecoverParams.eventSubscriptionToken - this.begin = eventSubscriptionRecoverParams.begin - this.end = eventSubscriptionRecoverParams.end - additionalHeaders(eventSubscriptionRecoverParams.additionalHeaders) - additionalQueryParams(eventSubscriptionRecoverParams.additionalQueryParams) - additionalBodyProperties(eventSubscriptionRecoverParams.additionalBodyProperties) + eventSubscriptionToken = eventSubscriptionRecoverParams.eventSubscriptionToken + begin = eventSubscriptionRecoverParams.begin + end = eventSubscriptionRecoverParams.end + additionalHeaders = eventSubscriptionRecoverParams.additionalHeaders.toBuilder() + additionalQueryParams = eventSubscriptionRecoverParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + eventSubscriptionRecoverParams.additionalBodyProperties.toMutableMap() } fun eventSubscriptionToken(eventSubscriptionToken: String) = apply { @@ -246,4 +234,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionRecoverParams && eventSubscriptionToken == other.eventSubscriptionToken && begin == other.begin && end == other.end && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, begin, end, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "EventSubscriptionRecoverParams{eventSubscriptionToken=$eventSubscriptionToken, begin=$begin, end=$end, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionReplayMissingParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionReplayMissingParams.kt index 1755cd93..90eb57c5 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionReplayMissingParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionReplayMissingParams.kt @@ -28,6 +28,12 @@ constructor( fun end(): OffsetDateTime? = end + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -53,25 +59,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionReplayMissingParams && eventSubscriptionToken == other.eventSubscriptionToken && begin == other.begin && end == other.end && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, begin, end, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "EventSubscriptionReplayMissingParams{eventSubscriptionToken=$eventSubscriptionToken, begin=$begin, end=$end, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -92,13 +79,14 @@ constructor( internal fun from( eventSubscriptionReplayMissingParams: EventSubscriptionReplayMissingParams ) = apply { - this.eventSubscriptionToken = - eventSubscriptionReplayMissingParams.eventSubscriptionToken - this.begin = eventSubscriptionReplayMissingParams.begin - this.end = eventSubscriptionReplayMissingParams.end - additionalHeaders(eventSubscriptionReplayMissingParams.additionalHeaders) - additionalQueryParams(eventSubscriptionReplayMissingParams.additionalQueryParams) - additionalBodyProperties(eventSubscriptionReplayMissingParams.additionalBodyProperties) + eventSubscriptionToken = eventSubscriptionReplayMissingParams.eventSubscriptionToken + begin = eventSubscriptionReplayMissingParams.begin + end = eventSubscriptionReplayMissingParams.end + additionalHeaders = eventSubscriptionReplayMissingParams.additionalHeaders.toBuilder() + additionalQueryParams = + eventSubscriptionReplayMissingParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + eventSubscriptionReplayMissingParams.additionalBodyProperties.toMutableMap() } fun eventSubscriptionToken(eventSubscriptionToken: String) = apply { @@ -249,4 +237,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionReplayMissingParams && eventSubscriptionToken == other.eventSubscriptionToken && begin == other.begin && end == other.end && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, begin, end, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "EventSubscriptionReplayMissingParams{eventSubscriptionToken=$eventSubscriptionToken, begin=$begin, end=$end, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRetrieveParams.kt index 557ab189..c27de7aa 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun eventSubscriptionToken(): String = eventSubscriptionToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionRetrieveParams && eventSubscriptionToken == other.eventSubscriptionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "EventSubscriptionRetrieveParams{eventSubscriptionToken=$eventSubscriptionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -61,9 +48,10 @@ constructor( internal fun from(eventSubscriptionRetrieveParams: EventSubscriptionRetrieveParams) = apply { - this.eventSubscriptionToken = eventSubscriptionRetrieveParams.eventSubscriptionToken - additionalHeaders(eventSubscriptionRetrieveParams.additionalHeaders) - additionalQueryParams(eventSubscriptionRetrieveParams.additionalQueryParams) + eventSubscriptionToken = eventSubscriptionRetrieveParams.eventSubscriptionToken + additionalHeaders = eventSubscriptionRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + eventSubscriptionRetrieveParams.additionalQueryParams.toBuilder() } fun eventSubscriptionToken(eventSubscriptionToken: String) = apply { @@ -177,4 +165,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionRetrieveParams && eventSubscriptionToken == other.eventSubscriptionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "EventSubscriptionRetrieveParams{eventSubscriptionToken=$eventSubscriptionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRetrieveSecretParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRetrieveSecretParams.kt index fa871476..15ac3d97 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRetrieveSecretParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRetrieveSecretParams.kt @@ -17,6 +17,10 @@ constructor( fun eventSubscriptionToken(): String = eventSubscriptionToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionRetrieveSecretParams && eventSubscriptionToken == other.eventSubscriptionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "EventSubscriptionRetrieveSecretParams{eventSubscriptionToken=$eventSubscriptionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -62,10 +49,10 @@ constructor( internal fun from( eventSubscriptionRetrieveSecretParams: EventSubscriptionRetrieveSecretParams ) = apply { - this.eventSubscriptionToken = - eventSubscriptionRetrieveSecretParams.eventSubscriptionToken - additionalHeaders(eventSubscriptionRetrieveSecretParams.additionalHeaders) - additionalQueryParams(eventSubscriptionRetrieveSecretParams.additionalQueryParams) + eventSubscriptionToken = eventSubscriptionRetrieveSecretParams.eventSubscriptionToken + additionalHeaders = eventSubscriptionRetrieveSecretParams.additionalHeaders.toBuilder() + additionalQueryParams = + eventSubscriptionRetrieveSecretParams.additionalQueryParams.toBuilder() } fun eventSubscriptionToken(eventSubscriptionToken: String) = apply { @@ -179,4 +166,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionRetrieveSecretParams && eventSubscriptionToken == other.eventSubscriptionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "EventSubscriptionRetrieveSecretParams{eventSubscriptionToken=$eventSubscriptionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRotateSecretParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRotateSecretParams.kt index 463041c9..ab4c899b 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRotateSecretParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionRotateSecretParams.kt @@ -20,6 +20,12 @@ constructor( fun eventSubscriptionToken(): String = eventSubscriptionToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionRotateSecretParams && eventSubscriptionToken == other.eventSubscriptionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "EventSubscriptionRotateSecretParams{eventSubscriptionToken=$eventSubscriptionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -72,10 +59,12 @@ constructor( internal fun from( eventSubscriptionRotateSecretParams: EventSubscriptionRotateSecretParams ) = apply { - this.eventSubscriptionToken = eventSubscriptionRotateSecretParams.eventSubscriptionToken - additionalHeaders(eventSubscriptionRotateSecretParams.additionalHeaders) - additionalQueryParams(eventSubscriptionRotateSecretParams.additionalQueryParams) - additionalBodyProperties(eventSubscriptionRotateSecretParams.additionalBodyProperties) + eventSubscriptionToken = eventSubscriptionRotateSecretParams.eventSubscriptionToken + additionalHeaders = eventSubscriptionRotateSecretParams.additionalHeaders.toBuilder() + additionalQueryParams = + eventSubscriptionRotateSecretParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + eventSubscriptionRotateSecretParams.additionalBodyProperties.toMutableMap() } fun eventSubscriptionToken(eventSubscriptionToken: String) = apply { @@ -212,4 +201,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionRotateSecretParams && eventSubscriptionToken == other.eventSubscriptionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "EventSubscriptionRotateSecretParams{eventSubscriptionToken=$eventSubscriptionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionSendSimulatedExampleParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionSendSimulatedExampleParams.kt index c6c0b55b..d5a59f1f 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionSendSimulatedExampleParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionSendSimulatedExampleParams.kt @@ -32,6 +32,12 @@ constructor( fun eventType(): EventType? = eventType + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): EventSubscriptionSendSimulatedExampleBody { return EventSubscriptionSendSimulatedExampleBody(eventType, additionalBodyProperties) } @@ -124,25 +130,6 @@ constructor( "EventSubscriptionSendSimulatedExampleBody{eventType=$eventType, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionSendSimulatedExampleParams && eventSubscriptionToken == other.eventSubscriptionToken && eventType == other.eventType && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, eventType, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "EventSubscriptionSendSimulatedExampleParams{eventSubscriptionToken=$eventSubscriptionToken, eventType=$eventType, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -162,14 +149,15 @@ constructor( internal fun from( eventSubscriptionSendSimulatedExampleParams: EventSubscriptionSendSimulatedExampleParams ) = apply { - this.eventSubscriptionToken = + eventSubscriptionToken = eventSubscriptionSendSimulatedExampleParams.eventSubscriptionToken - this.eventType = eventSubscriptionSendSimulatedExampleParams.eventType - additionalHeaders(eventSubscriptionSendSimulatedExampleParams.additionalHeaders) - additionalQueryParams(eventSubscriptionSendSimulatedExampleParams.additionalQueryParams) - additionalBodyProperties( - eventSubscriptionSendSimulatedExampleParams.additionalBodyProperties - ) + eventType = eventSubscriptionSendSimulatedExampleParams.eventType + additionalHeaders = + eventSubscriptionSendSimulatedExampleParams.additionalHeaders.toBuilder() + additionalQueryParams = + eventSubscriptionSendSimulatedExampleParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + eventSubscriptionSendSimulatedExampleParams.additionalBodyProperties.toMutableMap() } fun eventSubscriptionToken(eventSubscriptionToken: String) = apply { @@ -613,4 +601,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionSendSimulatedExampleParams && eventSubscriptionToken == other.eventSubscriptionToken && eventType == other.eventType && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, eventType, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "EventSubscriptionSendSimulatedExampleParams{eventSubscriptionToken=$eventSubscriptionToken, eventType=$eventType, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionUpdateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionUpdateParams.kt index 345d42b4..3997a2f4 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionUpdateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/EventSubscriptionUpdateParams.kt @@ -41,6 +41,12 @@ constructor( fun eventTypes(): List? = eventTypes + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): EventSubscriptionUpdateBody { return EventSubscriptionUpdateBody( url, @@ -175,25 +181,6 @@ constructor( "EventSubscriptionUpdateBody{url=$url, description=$description, disabled=$disabled, eventTypes=$eventTypes, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is EventSubscriptionUpdateParams && eventSubscriptionToken == other.eventSubscriptionToken && url == other.url && description == other.description && disabled == other.disabled && eventTypes == other.eventTypes && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, url, description, disabled, eventTypes, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "EventSubscriptionUpdateParams{eventSubscriptionToken=$eventSubscriptionToken, url=$url, description=$description, disabled=$disabled, eventTypes=$eventTypes, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -214,14 +201,16 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(eventSubscriptionUpdateParams: EventSubscriptionUpdateParams) = apply { - this.eventSubscriptionToken = eventSubscriptionUpdateParams.eventSubscriptionToken - this.url = eventSubscriptionUpdateParams.url - this.description = eventSubscriptionUpdateParams.description - this.disabled = eventSubscriptionUpdateParams.disabled - this.eventTypes(eventSubscriptionUpdateParams.eventTypes ?: listOf()) - additionalHeaders(eventSubscriptionUpdateParams.additionalHeaders) - additionalQueryParams(eventSubscriptionUpdateParams.additionalQueryParams) - additionalBodyProperties(eventSubscriptionUpdateParams.additionalBodyProperties) + eventSubscriptionToken = eventSubscriptionUpdateParams.eventSubscriptionToken + url = eventSubscriptionUpdateParams.url + description = eventSubscriptionUpdateParams.description + disabled = eventSubscriptionUpdateParams.disabled + eventTypes = + eventSubscriptionUpdateParams.eventTypes?.toMutableList() ?: mutableListOf() + additionalHeaders = eventSubscriptionUpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = eventSubscriptionUpdateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + eventSubscriptionUpdateParams.additionalBodyProperties.toMutableMap() } fun eventSubscriptionToken(eventSubscriptionToken: String) = apply { @@ -380,7 +369,7 @@ constructor( checkNotNull(url) { "`url` is required but was not set" }, description, disabled, - if (eventTypes.size == 0) null else eventTypes.toImmutable(), + eventTypes.toImmutable().ifEmpty { null }, additionalHeaders.build(), additionalQueryParams.build(), additionalBodyProperties.toImmutable(), @@ -689,4 +678,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is EventSubscriptionUpdateParams && eventSubscriptionToken == other.eventSubscriptionToken && url == other.url && description == other.description && disabled == other.disabled && eventTypes == other.eventTypes && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventSubscriptionToken, url, description, disabled, eventTypes, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "EventSubscriptionUpdateParams{eventSubscriptionToken=$eventSubscriptionToken, url=$url, description=$description, disabled=$disabled, eventTypes=$eventTypes, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountCreateParams.kt index 9e228a32..49ee1560 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountCreateParams.kt @@ -49,6 +49,10 @@ constructor( ExternallyVerifiedCreateBankAccountApiRequest? = externallyVerifiedCreateBankAccountApiRequest + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getBody(): ExternalBankAccountCreateBody { return ExternalBankAccountCreateBody( bankVerifiedCreateBankAccountApiRequest, @@ -254,23 +258,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalBankAccountCreateParams && bankVerifiedCreateBankAccountApiRequest == other.bankVerifiedCreateBankAccountApiRequest && plaidCreateBankAccountApiRequest == other.plaidCreateBankAccountApiRequest && externallyVerifiedCreateBankAccountApiRequest == other.externallyVerifiedCreateBankAccountApiRequest && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(bankVerifiedCreateBankAccountApiRequest, plaidCreateBankAccountApiRequest, externallyVerifiedCreateBankAccountApiRequest, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ExternalBankAccountCreateParams{bankVerifiedCreateBankAccountApiRequest=$bankVerifiedCreateBankAccountApiRequest, plaidCreateBankAccountApiRequest=$plaidCreateBankAccountApiRequest, externallyVerifiedCreateBankAccountApiRequest=$externallyVerifiedCreateBankAccountApiRequest, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -293,14 +280,15 @@ constructor( internal fun from(externalBankAccountCreateParams: ExternalBankAccountCreateParams) = apply { - this.bankVerifiedCreateBankAccountApiRequest = + bankVerifiedCreateBankAccountApiRequest = externalBankAccountCreateParams.bankVerifiedCreateBankAccountApiRequest - this.plaidCreateBankAccountApiRequest = + plaidCreateBankAccountApiRequest = externalBankAccountCreateParams.plaidCreateBankAccountApiRequest - this.externallyVerifiedCreateBankAccountApiRequest = + externallyVerifiedCreateBankAccountApiRequest = externalBankAccountCreateParams.externallyVerifiedCreateBankAccountApiRequest - additionalHeaders(externalBankAccountCreateParams.additionalHeaders) - additionalQueryParams(externalBankAccountCreateParams.additionalQueryParams) + additionalHeaders = externalBankAccountCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = + externalBankAccountCreateParams.additionalQueryParams.toBuilder() } fun forBankVerifiedCreateBankAccountApiRequest( @@ -1326,4 +1314,17 @@ constructor( override fun toString() = "ExternallyVerifiedCreateBankAccountApiRequest{verificationMethod=$verificationMethod, ownerType=$ownerType, owner=$owner, accountToken=$accountToken, companyId=$companyId, doingBusinessAs=$doingBusinessAs, dob=$dob, userDefinedId=$userDefinedId, type=$type, routingNumber=$routingNumber, accountNumber=$accountNumber, name=$name, country=$country, currency=$currency, address=$address, additionalProperties=$additionalProperties}" } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalBankAccountCreateParams && bankVerifiedCreateBankAccountApiRequest == other.bankVerifiedCreateBankAccountApiRequest && plaidCreateBankAccountApiRequest == other.plaidCreateBankAccountApiRequest && externallyVerifiedCreateBankAccountApiRequest == other.externallyVerifiedCreateBankAccountApiRequest && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(bankVerifiedCreateBankAccountApiRequest, plaidCreateBankAccountApiRequest, externallyVerifiedCreateBankAccountApiRequest, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ExternalBankAccountCreateParams{bankVerifiedCreateBankAccountApiRequest=$bankVerifiedCreateBankAccountApiRequest, plaidCreateBankAccountApiRequest=$plaidCreateBankAccountApiRequest, externallyVerifiedCreateBankAccountApiRequest=$externallyVerifiedCreateBankAccountApiRequest, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountListParams.kt index 252228b6..2b5c02e8 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountListParams.kt @@ -47,6 +47,10 @@ constructor( fun verificationStates(): List? = verificationStates + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -72,23 +76,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalBankAccountListParams && accountToken == other.accountToken && accountTypes == other.accountTypes && countries == other.countries && endingBefore == other.endingBefore && ownerTypes == other.ownerTypes && pageSize == other.pageSize && startingAfter == other.startingAfter && states == other.states && verificationStates == other.verificationStates && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, accountTypes, countries, endingBefore, ownerTypes, pageSize, startingAfter, states, verificationStates, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ExternalBankAccountListParams{accountToken=$accountToken, accountTypes=$accountTypes, countries=$countries, endingBefore=$endingBefore, ownerTypes=$ownerTypes, pageSize=$pageSize, startingAfter=$startingAfter, states=$states, verificationStates=$verificationStates, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -112,17 +99,20 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(externalBankAccountListParams: ExternalBankAccountListParams) = apply { - this.accountToken = externalBankAccountListParams.accountToken - this.accountTypes(externalBankAccountListParams.accountTypes ?: listOf()) - this.countries(externalBankAccountListParams.countries ?: listOf()) - this.endingBefore = externalBankAccountListParams.endingBefore - this.ownerTypes(externalBankAccountListParams.ownerTypes ?: listOf()) - this.pageSize = externalBankAccountListParams.pageSize - this.startingAfter = externalBankAccountListParams.startingAfter - this.states(externalBankAccountListParams.states ?: listOf()) - this.verificationStates(externalBankAccountListParams.verificationStates ?: listOf()) - additionalHeaders(externalBankAccountListParams.additionalHeaders) - additionalQueryParams(externalBankAccountListParams.additionalQueryParams) + accountToken = externalBankAccountListParams.accountToken + accountTypes = + externalBankAccountListParams.accountTypes?.toMutableList() ?: mutableListOf() + countries = externalBankAccountListParams.countries?.toMutableList() ?: mutableListOf() + endingBefore = externalBankAccountListParams.endingBefore + ownerTypes = + externalBankAccountListParams.ownerTypes?.toMutableList() ?: mutableListOf() + pageSize = externalBankAccountListParams.pageSize + startingAfter = externalBankAccountListParams.startingAfter + states = externalBankAccountListParams.states?.toMutableList() ?: mutableListOf() + verificationStates = + externalBankAccountListParams.verificationStates?.toMutableList() ?: mutableListOf() + additionalHeaders = externalBankAccountListParams.additionalHeaders.toBuilder() + additionalQueryParams = externalBankAccountListParams.additionalQueryParams.toBuilder() } fun accountToken(accountToken: String) = apply { this.accountToken = accountToken } @@ -280,14 +270,14 @@ constructor( fun build(): ExternalBankAccountListParams = ExternalBankAccountListParams( accountToken, - if (accountTypes.size == 0) null else accountTypes.toImmutable(), - if (countries.size == 0) null else countries.toImmutable(), + accountTypes.toImmutable().ifEmpty { null }, + countries.toImmutable().ifEmpty { null }, endingBefore, - if (ownerTypes.size == 0) null else ownerTypes.toImmutable(), + ownerTypes.toImmutable().ifEmpty { null }, pageSize, startingAfter, - if (states.size == 0) null else states.toImmutable(), - if (verificationStates.size == 0) null else verificationStates.toImmutable(), + states.toImmutable().ifEmpty { null }, + verificationStates.toImmutable().ifEmpty { null }, additionalHeaders.build(), additionalQueryParams.build(), ) @@ -481,4 +471,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalBankAccountListParams && accountToken == other.accountToken && accountTypes == other.accountTypes && countries == other.countries && endingBefore == other.endingBefore && ownerTypes == other.ownerTypes && pageSize == other.pageSize && startingAfter == other.startingAfter && states == other.states && verificationStates == other.verificationStates && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, accountTypes, countries, endingBefore, ownerTypes, pageSize, startingAfter, states, verificationStates, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ExternalBankAccountListParams{accountToken=$accountToken, accountTypes=$accountTypes, countries=$countries, endingBefore=$endingBefore, ownerTypes=$ownerTypes, pageSize=$pageSize, startingAfter=$startingAfter, states=$states, verificationStates=$verificationStates, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountMicroDepositCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountMicroDepositCreateParams.kt index 3f3563da..0b31f5f8 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountMicroDepositCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountMicroDepositCreateParams.kt @@ -28,6 +28,12 @@ constructor( fun microDeposits(): List = microDeposits + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ExternalBankAccountMicroDepositCreateBody { return ExternalBankAccountMicroDepositCreateBody(microDeposits, additionalBodyProperties) } @@ -121,25 +127,6 @@ constructor( "ExternalBankAccountMicroDepositCreateBody{microDeposits=$microDeposits, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalBankAccountMicroDepositCreateParams && externalBankAccountToken == other.externalBankAccountToken && microDeposits == other.microDeposits && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, microDeposits, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ExternalBankAccountMicroDepositCreateParams{externalBankAccountToken=$externalBankAccountToken, microDeposits=$microDeposits, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -159,14 +146,16 @@ constructor( internal fun from( externalBankAccountMicroDepositCreateParams: ExternalBankAccountMicroDepositCreateParams ) = apply { - this.externalBankAccountToken = + externalBankAccountToken = externalBankAccountMicroDepositCreateParams.externalBankAccountToken - this.microDeposits(externalBankAccountMicroDepositCreateParams.microDeposits) - additionalHeaders(externalBankAccountMicroDepositCreateParams.additionalHeaders) - additionalQueryParams(externalBankAccountMicroDepositCreateParams.additionalQueryParams) - additionalBodyProperties( - externalBankAccountMicroDepositCreateParams.additionalBodyProperties - ) + microDeposits = + externalBankAccountMicroDepositCreateParams.microDeposits.toMutableList() + additionalHeaders = + externalBankAccountMicroDepositCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = + externalBankAccountMicroDepositCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + externalBankAccountMicroDepositCreateParams.additionalBodyProperties.toMutableMap() } fun externalBankAccountToken(externalBankAccountToken: String) = apply { @@ -305,11 +294,23 @@ constructor( checkNotNull(externalBankAccountToken) { "`externalBankAccountToken` is required but was not set" }, - checkNotNull(microDeposits) { "`microDeposits` is required but was not set" } - .toImmutable(), + microDeposits.toImmutable(), additionalHeaders.build(), additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalBankAccountMicroDepositCreateParams && externalBankAccountToken == other.externalBankAccountToken && microDeposits == other.microDeposits && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, microDeposits, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ExternalBankAccountMicroDepositCreateParams{externalBankAccountToken=$externalBankAccountToken, microDeposits=$microDeposits, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetrieveParams.kt index d8f07e2a..f7289a38 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun externalBankAccountToken(): String = externalBankAccountToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalBankAccountRetrieveParams && externalBankAccountToken == other.externalBankAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ExternalBankAccountRetrieveParams{externalBankAccountToken=$externalBankAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -61,10 +48,11 @@ constructor( internal fun from(externalBankAccountRetrieveParams: ExternalBankAccountRetrieveParams) = apply { - this.externalBankAccountToken = + externalBankAccountToken = externalBankAccountRetrieveParams.externalBankAccountToken - additionalHeaders(externalBankAccountRetrieveParams.additionalHeaders) - additionalQueryParams(externalBankAccountRetrieveParams.additionalQueryParams) + additionalHeaders = externalBankAccountRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + externalBankAccountRetrieveParams.additionalQueryParams.toBuilder() } fun externalBankAccountToken(externalBankAccountToken: String) = apply { @@ -178,4 +166,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalBankAccountRetrieveParams && externalBankAccountToken == other.externalBankAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ExternalBankAccountRetrieveParams{externalBankAccountToken=$externalBankAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetryMicroDepositsParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetryMicroDepositsParams.kt index 79db88d9..d2f72aa2 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetryMicroDepositsParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetryMicroDepositsParams.kt @@ -28,6 +28,12 @@ constructor( fun financialAccountToken(): String? = financialAccountToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ExternalBankAccountRetryMicroDepositsBody { return ExternalBankAccountRetryMicroDepositsBody( financialAccountToken, @@ -125,25 +131,6 @@ constructor( "ExternalBankAccountRetryMicroDepositsBody{financialAccountToken=$financialAccountToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalBankAccountRetryMicroDepositsParams && externalBankAccountToken == other.externalBankAccountToken && financialAccountToken == other.financialAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, financialAccountToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ExternalBankAccountRetryMicroDepositsParams{externalBankAccountToken=$externalBankAccountToken, financialAccountToken=$financialAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -163,15 +150,16 @@ constructor( internal fun from( externalBankAccountRetryMicroDepositsParams: ExternalBankAccountRetryMicroDepositsParams ) = apply { - this.externalBankAccountToken = + externalBankAccountToken = externalBankAccountRetryMicroDepositsParams.externalBankAccountToken - this.financialAccountToken = + financialAccountToken = externalBankAccountRetryMicroDepositsParams.financialAccountToken - additionalHeaders(externalBankAccountRetryMicroDepositsParams.additionalHeaders) - additionalQueryParams(externalBankAccountRetryMicroDepositsParams.additionalQueryParams) - additionalBodyProperties( - externalBankAccountRetryMicroDepositsParams.additionalBodyProperties - ) + additionalHeaders = + externalBankAccountRetryMicroDepositsParams.additionalHeaders.toBuilder() + additionalQueryParams = + externalBankAccountRetryMicroDepositsParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + externalBankAccountRetryMicroDepositsParams.additionalBodyProperties.toMutableMap() } fun externalBankAccountToken(externalBankAccountToken: String) = apply { @@ -313,4 +301,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalBankAccountRetryMicroDepositsParams && externalBankAccountToken == other.externalBankAccountToken && financialAccountToken == other.financialAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, financialAccountToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ExternalBankAccountRetryMicroDepositsParams{externalBankAccountToken=$externalBankAccountToken, financialAccountToken=$financialAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetryPrenoteParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetryPrenoteParams.kt index 3a5399d3..8ce8cbea 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetryPrenoteParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountRetryPrenoteParams.kt @@ -28,6 +28,12 @@ constructor( fun financialAccountToken(): String? = financialAccountToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ExternalBankAccountRetryPrenoteBody { return ExternalBankAccountRetryPrenoteBody(financialAccountToken, additionalBodyProperties) } @@ -122,25 +128,6 @@ constructor( "ExternalBankAccountRetryPrenoteBody{financialAccountToken=$financialAccountToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalBankAccountRetryPrenoteParams && externalBankAccountToken == other.externalBankAccountToken && financialAccountToken == other.financialAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, financialAccountToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ExternalBankAccountRetryPrenoteParams{externalBankAccountToken=$externalBankAccountToken, financialAccountToken=$financialAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -160,12 +147,14 @@ constructor( internal fun from( externalBankAccountRetryPrenoteParams: ExternalBankAccountRetryPrenoteParams ) = apply { - this.externalBankAccountToken = + externalBankAccountToken = externalBankAccountRetryPrenoteParams.externalBankAccountToken - this.financialAccountToken = externalBankAccountRetryPrenoteParams.financialAccountToken - additionalHeaders(externalBankAccountRetryPrenoteParams.additionalHeaders) - additionalQueryParams(externalBankAccountRetryPrenoteParams.additionalQueryParams) - additionalBodyProperties(externalBankAccountRetryPrenoteParams.additionalBodyProperties) + financialAccountToken = externalBankAccountRetryPrenoteParams.financialAccountToken + additionalHeaders = externalBankAccountRetryPrenoteParams.additionalHeaders.toBuilder() + additionalQueryParams = + externalBankAccountRetryPrenoteParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + externalBankAccountRetryPrenoteParams.additionalBodyProperties.toMutableMap() } fun externalBankAccountToken(externalBankAccountToken: String) = apply { @@ -307,4 +296,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalBankAccountRetryPrenoteParams && externalBankAccountToken == other.externalBankAccountToken && financialAccountToken == other.financialAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, financialAccountToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ExternalBankAccountRetryPrenoteParams{externalBankAccountToken=$externalBankAccountToken, financialAccountToken=$financialAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountUpdateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountUpdateParams.kt index 6a08d31e..21508b80 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountUpdateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalBankAccountUpdateParams.kt @@ -50,6 +50,12 @@ constructor( fun userDefinedId(): String? = userDefinedId + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ExternalBankAccountUpdateBody { return ExternalBankAccountUpdateBody( address, @@ -233,25 +239,6 @@ constructor( "ExternalBankAccountUpdateBody{address=$address, companyId=$companyId, dob=$dob, doingBusinessAs=$doingBusinessAs, name=$name, owner=$owner, ownerType=$ownerType, userDefinedId=$userDefinedId, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalBankAccountUpdateParams && externalBankAccountToken == other.externalBankAccountToken && address == other.address && companyId == other.companyId && dob == other.dob && doingBusinessAs == other.doingBusinessAs && name == other.name && owner == other.owner && ownerType == other.ownerType && userDefinedId == other.userDefinedId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, address, companyId, dob, doingBusinessAs, name, owner, ownerType, userDefinedId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ExternalBankAccountUpdateParams{externalBankAccountToken=$externalBankAccountToken, address=$address, companyId=$companyId, dob=$dob, doingBusinessAs=$doingBusinessAs, name=$name, owner=$owner, ownerType=$ownerType, userDefinedId=$userDefinedId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -277,19 +264,20 @@ constructor( internal fun from(externalBankAccountUpdateParams: ExternalBankAccountUpdateParams) = apply { - this.externalBankAccountToken = - externalBankAccountUpdateParams.externalBankAccountToken - this.address = externalBankAccountUpdateParams.address - this.companyId = externalBankAccountUpdateParams.companyId - this.dob = externalBankAccountUpdateParams.dob - this.doingBusinessAs = externalBankAccountUpdateParams.doingBusinessAs - this.name = externalBankAccountUpdateParams.name - this.owner = externalBankAccountUpdateParams.owner - this.ownerType = externalBankAccountUpdateParams.ownerType - this.userDefinedId = externalBankAccountUpdateParams.userDefinedId - additionalHeaders(externalBankAccountUpdateParams.additionalHeaders) - additionalQueryParams(externalBankAccountUpdateParams.additionalQueryParams) - additionalBodyProperties(externalBankAccountUpdateParams.additionalBodyProperties) + externalBankAccountToken = externalBankAccountUpdateParams.externalBankAccountToken + address = externalBankAccountUpdateParams.address + companyId = externalBankAccountUpdateParams.companyId + dob = externalBankAccountUpdateParams.dob + doingBusinessAs = externalBankAccountUpdateParams.doingBusinessAs + name = externalBankAccountUpdateParams.name + owner = externalBankAccountUpdateParams.owner + ownerType = externalBankAccountUpdateParams.ownerType + userDefinedId = externalBankAccountUpdateParams.userDefinedId + additionalHeaders = externalBankAccountUpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = + externalBankAccountUpdateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + externalBankAccountUpdateParams.additionalBodyProperties.toMutableMap() } fun externalBankAccountToken(externalBankAccountToken: String) = apply { @@ -463,4 +451,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalBankAccountUpdateParams && externalBankAccountToken == other.externalBankAccountToken && address == other.address && companyId == other.companyId && dob == other.dob && doingBusinessAs == other.doingBusinessAs && name == other.name && owner == other.owner && ownerType == other.ownerType && userDefinedId == other.userDefinedId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalBankAccountToken, address, companyId, dob, doingBusinessAs, name, owner, ownerType, userDefinedId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ExternalBankAccountUpdateParams{externalBankAccountToken=$externalBankAccountToken, address=$address, companyId=$companyId, dob=$dob, doingBusinessAs=$doingBusinessAs, name=$name, owner=$owner, ownerType=$ownerType, userDefinedId=$userDefinedId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentCancelParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentCancelParams.kt index 6388d6f9..a2a80a35 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentCancelParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentCancelParams.kt @@ -32,6 +32,12 @@ constructor( fun memo(): String? = memo + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ExternalPaymentCancelBody { return ExternalPaymentCancelBody( effectiveDate, @@ -134,25 +140,6 @@ constructor( "ExternalPaymentCancelBody{effectiveDate=$effectiveDate, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalPaymentCancelParams && externalPaymentToken == other.externalPaymentToken && effectiveDate == other.effectiveDate && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, effectiveDate, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ExternalPaymentCancelParams{externalPaymentToken=$externalPaymentToken, effectiveDate=$effectiveDate, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -171,12 +158,13 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentCancelParams: ExternalPaymentCancelParams) = apply { - this.externalPaymentToken = externalPaymentCancelParams.externalPaymentToken - this.effectiveDate = externalPaymentCancelParams.effectiveDate - this.memo = externalPaymentCancelParams.memo - additionalHeaders(externalPaymentCancelParams.additionalHeaders) - additionalQueryParams(externalPaymentCancelParams.additionalQueryParams) - additionalBodyProperties(externalPaymentCancelParams.additionalBodyProperties) + externalPaymentToken = externalPaymentCancelParams.externalPaymentToken + effectiveDate = externalPaymentCancelParams.effectiveDate + memo = externalPaymentCancelParams.memo + additionalHeaders = externalPaymentCancelParams.additionalHeaders.toBuilder() + additionalQueryParams = externalPaymentCancelParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + externalPaymentCancelParams.additionalBodyProperties.toMutableMap() } fun externalPaymentToken(externalPaymentToken: String) = apply { @@ -319,4 +307,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalPaymentCancelParams && externalPaymentToken == other.externalPaymentToken && effectiveDate == other.effectiveDate && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, effectiveDate, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ExternalPaymentCancelParams{externalPaymentToken=$externalPaymentToken, effectiveDate=$effectiveDate, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentCreateParams.kt index 6b8341fc..af67c4da 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentCreateParams.kt @@ -54,6 +54,12 @@ constructor( fun userDefinedId(): String? = userDefinedId + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ExternalPaymentCreateBody { return ExternalPaymentCreateBody( amount, @@ -226,25 +232,6 @@ constructor( "ExternalPaymentCreateBody{amount=$amount, category=$category, effectiveDate=$effectiveDate, financialAccountToken=$financialAccountToken, paymentType=$paymentType, token=$token, memo=$memo, progressTo=$progressTo, userDefinedId=$userDefinedId, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalPaymentCreateParams && amount == other.amount && category == other.category && effectiveDate == other.effectiveDate && financialAccountToken == other.financialAccountToken && paymentType == other.paymentType && token == other.token && memo == other.memo && progressTo == other.progressTo && userDefinedId == other.userDefinedId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, category, effectiveDate, financialAccountToken, paymentType, token, memo, progressTo, userDefinedId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ExternalPaymentCreateParams{amount=$amount, category=$category, effectiveDate=$effectiveDate, financialAccountToken=$financialAccountToken, paymentType=$paymentType, token=$token, memo=$memo, progressTo=$progressTo, userDefinedId=$userDefinedId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -269,18 +256,19 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentCreateParams: ExternalPaymentCreateParams) = apply { - this.amount = externalPaymentCreateParams.amount - this.category = externalPaymentCreateParams.category - this.effectiveDate = externalPaymentCreateParams.effectiveDate - this.financialAccountToken = externalPaymentCreateParams.financialAccountToken - this.paymentType = externalPaymentCreateParams.paymentType - this.token = externalPaymentCreateParams.token - this.memo = externalPaymentCreateParams.memo - this.progressTo = externalPaymentCreateParams.progressTo - this.userDefinedId = externalPaymentCreateParams.userDefinedId - additionalHeaders(externalPaymentCreateParams.additionalHeaders) - additionalQueryParams(externalPaymentCreateParams.additionalQueryParams) - additionalBodyProperties(externalPaymentCreateParams.additionalBodyProperties) + amount = externalPaymentCreateParams.amount + category = externalPaymentCreateParams.category + effectiveDate = externalPaymentCreateParams.effectiveDate + financialAccountToken = externalPaymentCreateParams.financialAccountToken + paymentType = externalPaymentCreateParams.paymentType + token = externalPaymentCreateParams.token + memo = externalPaymentCreateParams.memo + progressTo = externalPaymentCreateParams.progressTo + userDefinedId = externalPaymentCreateParams.userDefinedId + additionalHeaders = externalPaymentCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = externalPaymentCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + externalPaymentCreateParams.additionalBodyProperties.toMutableMap() } fun amount(amount: Long) = apply { this.amount = amount } @@ -629,4 +617,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalPaymentCreateParams && amount == other.amount && category == other.category && effectiveDate == other.effectiveDate && financialAccountToken == other.financialAccountToken && paymentType == other.paymentType && token == other.token && memo == other.memo && progressTo == other.progressTo && userDefinedId == other.userDefinedId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, category, effectiveDate, financialAccountToken, paymentType, token, memo, progressTo, userDefinedId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ExternalPaymentCreateParams{amount=$amount, category=$category, effectiveDate=$effectiveDate, financialAccountToken=$financialAccountToken, paymentType=$paymentType, token=$token, memo=$memo, progressTo=$progressTo, userDefinedId=$userDefinedId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentListParams.kt index 6c5c38d3..4b7ae387 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentListParams.kt @@ -51,6 +51,10 @@ constructor( fun status(): TransactionStatus? = status + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -77,23 +81,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalPaymentListParams && begin == other.begin && businessAccountToken == other.businessAccountToken && category == other.category && end == other.end && endingBefore == other.endingBefore && financialAccountToken == other.financialAccountToken && pageSize == other.pageSize && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, businessAccountToken, category, end, endingBefore, financialAccountToken, pageSize, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ExternalPaymentListParams{begin=$begin, businessAccountToken=$businessAccountToken, category=$category, end=$end, endingBefore=$endingBefore, financialAccountToken=$financialAccountToken, pageSize=$pageSize, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -118,18 +105,18 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(externalPaymentListParams: ExternalPaymentListParams) = apply { - this.begin = externalPaymentListParams.begin - this.businessAccountToken = externalPaymentListParams.businessAccountToken - this.category = externalPaymentListParams.category - this.end = externalPaymentListParams.end - this.endingBefore = externalPaymentListParams.endingBefore - this.financialAccountToken = externalPaymentListParams.financialAccountToken - this.pageSize = externalPaymentListParams.pageSize - this.result = externalPaymentListParams.result - this.startingAfter = externalPaymentListParams.startingAfter - this.status = externalPaymentListParams.status - additionalHeaders(externalPaymentListParams.additionalHeaders) - additionalQueryParams(externalPaymentListParams.additionalQueryParams) + begin = externalPaymentListParams.begin + businessAccountToken = externalPaymentListParams.businessAccountToken + category = externalPaymentListParams.category + end = externalPaymentListParams.end + endingBefore = externalPaymentListParams.endingBefore + financialAccountToken = externalPaymentListParams.financialAccountToken + pageSize = externalPaymentListParams.pageSize + result = externalPaymentListParams.result + startingAfter = externalPaymentListParams.startingAfter + status = externalPaymentListParams.status + additionalHeaders = externalPaymentListParams.additionalHeaders.toBuilder() + additionalQueryParams = externalPaymentListParams.additionalQueryParams.toBuilder() } /** @@ -495,4 +482,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalPaymentListParams && begin == other.begin && businessAccountToken == other.businessAccountToken && category == other.category && end == other.end && endingBefore == other.endingBefore && financialAccountToken == other.financialAccountToken && pageSize == other.pageSize && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, businessAccountToken, category, end, endingBefore, financialAccountToken, pageSize, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ExternalPaymentListParams{begin=$begin, businessAccountToken=$businessAccountToken, category=$category, end=$end, endingBefore=$endingBefore, financialAccountToken=$financialAccountToken, pageSize=$pageSize, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentReleaseParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentReleaseParams.kt index 61fc75ac..9e9ae126 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentReleaseParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentReleaseParams.kt @@ -32,6 +32,12 @@ constructor( fun memo(): String? = memo + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ExternalPaymentReleaseBody { return ExternalPaymentReleaseBody( effectiveDate, @@ -134,25 +140,6 @@ constructor( "ExternalPaymentReleaseBody{effectiveDate=$effectiveDate, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalPaymentReleaseParams && externalPaymentToken == other.externalPaymentToken && effectiveDate == other.effectiveDate && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, effectiveDate, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ExternalPaymentReleaseParams{externalPaymentToken=$externalPaymentToken, effectiveDate=$effectiveDate, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -171,12 +158,13 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentReleaseParams: ExternalPaymentReleaseParams) = apply { - this.externalPaymentToken = externalPaymentReleaseParams.externalPaymentToken - this.effectiveDate = externalPaymentReleaseParams.effectiveDate - this.memo = externalPaymentReleaseParams.memo - additionalHeaders(externalPaymentReleaseParams.additionalHeaders) - additionalQueryParams(externalPaymentReleaseParams.additionalQueryParams) - additionalBodyProperties(externalPaymentReleaseParams.additionalBodyProperties) + externalPaymentToken = externalPaymentReleaseParams.externalPaymentToken + effectiveDate = externalPaymentReleaseParams.effectiveDate + memo = externalPaymentReleaseParams.memo + additionalHeaders = externalPaymentReleaseParams.additionalHeaders.toBuilder() + additionalQueryParams = externalPaymentReleaseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + externalPaymentReleaseParams.additionalBodyProperties.toMutableMap() } fun externalPaymentToken(externalPaymentToken: String) = apply { @@ -319,4 +307,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalPaymentReleaseParams && externalPaymentToken == other.externalPaymentToken && effectiveDate == other.effectiveDate && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, effectiveDate, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ExternalPaymentReleaseParams{externalPaymentToken=$externalPaymentToken, effectiveDate=$effectiveDate, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentRetrieveParams.kt index 54f2ffeb..57141458 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun externalPaymentToken(): String = externalPaymentToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalPaymentRetrieveParams && externalPaymentToken == other.externalPaymentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ExternalPaymentRetrieveParams{externalPaymentToken=$externalPaymentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(externalPaymentRetrieveParams: ExternalPaymentRetrieveParams) = apply { - this.externalPaymentToken = externalPaymentRetrieveParams.externalPaymentToken - additionalHeaders(externalPaymentRetrieveParams.additionalHeaders) - additionalQueryParams(externalPaymentRetrieveParams.additionalQueryParams) + externalPaymentToken = externalPaymentRetrieveParams.externalPaymentToken + additionalHeaders = externalPaymentRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = externalPaymentRetrieveParams.additionalQueryParams.toBuilder() } fun externalPaymentToken(externalPaymentToken: String) = apply { @@ -176,4 +163,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalPaymentRetrieveParams && externalPaymentToken == other.externalPaymentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ExternalPaymentRetrieveParams{externalPaymentToken=$externalPaymentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentReverseParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentReverseParams.kt index 4bffad1c..07d1de6d 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentReverseParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentReverseParams.kt @@ -32,6 +32,12 @@ constructor( fun memo(): String? = memo + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ExternalPaymentReverseBody { return ExternalPaymentReverseBody( effectiveDate, @@ -134,25 +140,6 @@ constructor( "ExternalPaymentReverseBody{effectiveDate=$effectiveDate, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalPaymentReverseParams && externalPaymentToken == other.externalPaymentToken && effectiveDate == other.effectiveDate && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, effectiveDate, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ExternalPaymentReverseParams{externalPaymentToken=$externalPaymentToken, effectiveDate=$effectiveDate, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -171,12 +158,13 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentReverseParams: ExternalPaymentReverseParams) = apply { - this.externalPaymentToken = externalPaymentReverseParams.externalPaymentToken - this.effectiveDate = externalPaymentReverseParams.effectiveDate - this.memo = externalPaymentReverseParams.memo - additionalHeaders(externalPaymentReverseParams.additionalHeaders) - additionalQueryParams(externalPaymentReverseParams.additionalQueryParams) - additionalBodyProperties(externalPaymentReverseParams.additionalBodyProperties) + externalPaymentToken = externalPaymentReverseParams.externalPaymentToken + effectiveDate = externalPaymentReverseParams.effectiveDate + memo = externalPaymentReverseParams.memo + additionalHeaders = externalPaymentReverseParams.additionalHeaders.toBuilder() + additionalQueryParams = externalPaymentReverseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + externalPaymentReverseParams.additionalBodyProperties.toMutableMap() } fun externalPaymentToken(externalPaymentToken: String) = apply { @@ -319,4 +307,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalPaymentReverseParams && externalPaymentToken == other.externalPaymentToken && effectiveDate == other.effectiveDate && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, effectiveDate, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ExternalPaymentReverseParams{externalPaymentToken=$externalPaymentToken, effectiveDate=$effectiveDate, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentSettleParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentSettleParams.kt index d0d5633b..7f8a536c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentSettleParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ExternalPaymentSettleParams.kt @@ -39,6 +39,12 @@ constructor( fun progressTo(): ExternalPaymentProgressTo? = progressTo + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ExternalPaymentSettleBody { return ExternalPaymentSettleBody( effectiveDate, @@ -153,25 +159,6 @@ constructor( "ExternalPaymentSettleBody{effectiveDate=$effectiveDate, memo=$memo, progressTo=$progressTo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ExternalPaymentSettleParams && externalPaymentToken == other.externalPaymentToken && effectiveDate == other.effectiveDate && memo == other.memo && progressTo == other.progressTo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, effectiveDate, memo, progressTo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ExternalPaymentSettleParams{externalPaymentToken=$externalPaymentToken, effectiveDate=$effectiveDate, memo=$memo, progressTo=$progressTo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -191,13 +178,14 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentSettleParams: ExternalPaymentSettleParams) = apply { - this.externalPaymentToken = externalPaymentSettleParams.externalPaymentToken - this.effectiveDate = externalPaymentSettleParams.effectiveDate - this.memo = externalPaymentSettleParams.memo - this.progressTo = externalPaymentSettleParams.progressTo - additionalHeaders(externalPaymentSettleParams.additionalHeaders) - additionalQueryParams(externalPaymentSettleParams.additionalQueryParams) - additionalBodyProperties(externalPaymentSettleParams.additionalBodyProperties) + externalPaymentToken = externalPaymentSettleParams.externalPaymentToken + effectiveDate = externalPaymentSettleParams.effectiveDate + memo = externalPaymentSettleParams.memo + progressTo = externalPaymentSettleParams.progressTo + additionalHeaders = externalPaymentSettleParams.additionalHeaders.toBuilder() + additionalQueryParams = externalPaymentSettleParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + externalPaymentSettleParams.additionalBodyProperties.toMutableMap() } fun externalPaymentToken(externalPaymentToken: String) = apply { @@ -403,4 +391,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ExternalPaymentSettleParams && externalPaymentToken == other.externalPaymentToken && effectiveDate == other.effectiveDate && memo == other.memo && progressTo == other.progressTo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(externalPaymentToken, effectiveDate, memo, progressTo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ExternalPaymentSettleParams{externalPaymentToken=$externalPaymentToken, effectiveDate=$effectiveDate, memo=$memo, progressTo=$progressTo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountBalanceListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountBalanceListParams.kt index f3adfa9a..f9f8e69f 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountBalanceListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountBalanceListParams.kt @@ -25,6 +25,10 @@ constructor( fun lastTransactionEventToken(): String? = lastTransactionEventToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -49,23 +53,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountBalanceListParams && financialAccountToken == other.financialAccountToken && balanceDate == other.balanceDate && lastTransactionEventToken == other.lastTransactionEventToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, balanceDate, lastTransactionEventToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialAccountBalanceListParams{financialAccountToken=$financialAccountToken, balanceDate=$balanceDate, lastTransactionEventToken=$lastTransactionEventToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -84,12 +71,13 @@ constructor( internal fun from(financialAccountBalanceListParams: FinancialAccountBalanceListParams) = apply { - this.financialAccountToken = financialAccountBalanceListParams.financialAccountToken - this.balanceDate = financialAccountBalanceListParams.balanceDate - this.lastTransactionEventToken = + financialAccountToken = financialAccountBalanceListParams.financialAccountToken + balanceDate = financialAccountBalanceListParams.balanceDate + lastTransactionEventToken = financialAccountBalanceListParams.lastTransactionEventToken - additionalHeaders(financialAccountBalanceListParams.additionalHeaders) - additionalQueryParams(financialAccountBalanceListParams.additionalQueryParams) + additionalHeaders = financialAccountBalanceListParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialAccountBalanceListParams.additionalQueryParams.toBuilder() } fun financialAccountToken(financialAccountToken: String) = apply { @@ -216,4 +204,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountBalanceListParams && financialAccountToken == other.financialAccountToken && balanceDate == other.balanceDate && lastTransactionEventToken == other.lastTransactionEventToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, balanceDate, lastTransactionEventToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialAccountBalanceListParams{financialAccountToken=$financialAccountToken, balanceDate=$balanceDate, lastTransactionEventToken=$lastTransactionEventToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountChargeOffParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountChargeOffParams.kt index 3f7b88e0..00b57998 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountChargeOffParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountChargeOffParams.kt @@ -32,6 +32,12 @@ constructor( fun reason(): ChargedOffReason = reason + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): FinancialAccountChargeOffBody { return FinancialAccountChargeOffBody(reason, additionalBodyProperties) } @@ -123,25 +129,6 @@ constructor( "FinancialAccountChargeOffBody{reason=$reason, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountChargeOffParams && financialAccountToken == other.financialAccountToken && reason == other.reason && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, reason, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "FinancialAccountChargeOffParams{financialAccountToken=$financialAccountToken, reason=$reason, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -160,11 +147,13 @@ constructor( internal fun from(financialAccountChargeOffParams: FinancialAccountChargeOffParams) = apply { - this.financialAccountToken = financialAccountChargeOffParams.financialAccountToken - this.reason = financialAccountChargeOffParams.reason - additionalHeaders(financialAccountChargeOffParams.additionalHeaders) - additionalQueryParams(financialAccountChargeOffParams.additionalQueryParams) - additionalBodyProperties(financialAccountChargeOffParams.additionalBodyProperties) + financialAccountToken = financialAccountChargeOffParams.financialAccountToken + reason = financialAccountChargeOffParams.reason + additionalHeaders = financialAccountChargeOffParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialAccountChargeOffParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + financialAccountChargeOffParams.additionalBodyProperties.toMutableMap() } fun financialAccountToken(financialAccountToken: String) = apply { @@ -362,4 +351,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountChargeOffParams && financialAccountToken == other.financialAccountToken && reason == other.reason && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, reason, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "FinancialAccountChargeOffParams{financialAccountToken=$financialAccountToken, reason=$reason, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreateParams.kt index 7f03e631..78f34b4b 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreateParams.kt @@ -41,6 +41,12 @@ constructor( fun idempotencyKey(): String? = idempotencyKey + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): FinancialAccountCreateBody { return FinancialAccountCreateBody( nickname, @@ -161,25 +167,6 @@ constructor( "FinancialAccountCreateBody{nickname=$nickname, type=$type, accountToken=$accountToken, isForBenefitOf=$isForBenefitOf, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountCreateParams && nickname == other.nickname && type == other.type && accountToken == other.accountToken && isForBenefitOf == other.isForBenefitOf && idempotencyKey == other.idempotencyKey && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(nickname, type, accountToken, isForBenefitOf, idempotencyKey, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "FinancialAccountCreateParams{nickname=$nickname, type=$type, accountToken=$accountToken, isForBenefitOf=$isForBenefitOf, idempotencyKey=$idempotencyKey, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -200,14 +187,15 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(financialAccountCreateParams: FinancialAccountCreateParams) = apply { - this.nickname = financialAccountCreateParams.nickname - this.type = financialAccountCreateParams.type - this.accountToken = financialAccountCreateParams.accountToken - this.isForBenefitOf = financialAccountCreateParams.isForBenefitOf - this.idempotencyKey = financialAccountCreateParams.idempotencyKey - additionalHeaders(financialAccountCreateParams.additionalHeaders) - additionalQueryParams(financialAccountCreateParams.additionalQueryParams) - additionalBodyProperties(financialAccountCreateParams.additionalBodyProperties) + nickname = financialAccountCreateParams.nickname + type = financialAccountCreateParams.type + accountToken = financialAccountCreateParams.accountToken + isForBenefitOf = financialAccountCreateParams.isForBenefitOf + idempotencyKey = financialAccountCreateParams.idempotencyKey + additionalHeaders = financialAccountCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = financialAccountCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + financialAccountCreateParams.additionalBodyProperties.toMutableMap() } fun nickname(nickname: String) = apply { this.nickname = nickname } @@ -403,4 +391,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountCreateParams && nickname == other.nickname && type == other.type && accountToken == other.accountToken && isForBenefitOf == other.isForBenefitOf && idempotencyKey == other.idempotencyKey && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(nickname, type, accountToken, isForBenefitOf, idempotencyKey, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "FinancialAccountCreateParams{nickname=$nickname, type=$type, accountToken=$accountToken, isForBenefitOf=$isForBenefitOf, idempotencyKey=$idempotencyKey, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreditConfigurationRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreditConfigurationRetrieveParams.kt index fea2cf6a..4807279d 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreditConfigurationRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreditConfigurationRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun financialAccountToken(): String = financialAccountToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountCreditConfigurationRetrieveParams && financialAccountToken == other.financialAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialAccountCreditConfigurationRetrieveParams{financialAccountToken=$financialAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -63,12 +50,12 @@ constructor( financialAccountCreditConfigurationRetrieveParams: FinancialAccountCreditConfigurationRetrieveParams ) = apply { - this.financialAccountToken = + financialAccountToken = financialAccountCreditConfigurationRetrieveParams.financialAccountToken - additionalHeaders(financialAccountCreditConfigurationRetrieveParams.additionalHeaders) - additionalQueryParams( - financialAccountCreditConfigurationRetrieveParams.additionalQueryParams - ) + additionalHeaders = + financialAccountCreditConfigurationRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialAccountCreditConfigurationRetrieveParams.additionalQueryParams.toBuilder() } fun financialAccountToken(financialAccountToken: String) = apply { @@ -182,4 +169,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountCreditConfigurationRetrieveParams && financialAccountToken == other.financialAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialAccountCreditConfigurationRetrieveParams{financialAccountToken=$financialAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreditConfigurationUpdateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreditConfigurationUpdateParams.kt index 2376f60c..8344ebb4 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreditConfigurationUpdateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountCreditConfigurationUpdateParams.kt @@ -37,6 +37,12 @@ constructor( fun tier(): String? = tier + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): FinancialAccountCreditConfigurationUpdateBody { return FinancialAccountCreditConfigurationUpdateBody( creditLimit, @@ -173,25 +179,6 @@ constructor( "FinancialAccountCreditConfigurationUpdateBody{creditLimit=$creditLimit, creditProductToken=$creditProductToken, externalBankAccountToken=$externalBankAccountToken, tier=$tier, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountCreditConfigurationUpdateParams && financialAccountToken == other.financialAccountToken && creditLimit == other.creditLimit && creditProductToken == other.creditProductToken && externalBankAccountToken == other.externalBankAccountToken && tier == other.tier && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, creditLimit, creditProductToken, externalBankAccountToken, tier, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "FinancialAccountCreditConfigurationUpdateParams{financialAccountToken=$financialAccountToken, creditLimit=$creditLimit, creditProductToken=$creditProductToken, externalBankAccountToken=$externalBankAccountToken, tier=$tier, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -215,21 +202,20 @@ constructor( financialAccountCreditConfigurationUpdateParams: FinancialAccountCreditConfigurationUpdateParams ) = apply { - this.financialAccountToken = + financialAccountToken = financialAccountCreditConfigurationUpdateParams.financialAccountToken - this.creditLimit = financialAccountCreditConfigurationUpdateParams.creditLimit - this.creditProductToken = - financialAccountCreditConfigurationUpdateParams.creditProductToken - this.externalBankAccountToken = + creditLimit = financialAccountCreditConfigurationUpdateParams.creditLimit + creditProductToken = financialAccountCreditConfigurationUpdateParams.creditProductToken + externalBankAccountToken = financialAccountCreditConfigurationUpdateParams.externalBankAccountToken - this.tier = financialAccountCreditConfigurationUpdateParams.tier - additionalHeaders(financialAccountCreditConfigurationUpdateParams.additionalHeaders) - additionalQueryParams( - financialAccountCreditConfigurationUpdateParams.additionalQueryParams - ) - additionalBodyProperties( + tier = financialAccountCreditConfigurationUpdateParams.tier + additionalHeaders = + financialAccountCreditConfigurationUpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialAccountCreditConfigurationUpdateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = financialAccountCreditConfigurationUpdateParams.additionalBodyProperties - ) + .toMutableMap() } fun financialAccountToken(financialAccountToken: String) = apply { @@ -384,4 +370,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountCreditConfigurationUpdateParams && financialAccountToken == other.financialAccountToken && creditLimit == other.creditLimit && creditProductToken == other.creditProductToken && externalBankAccountToken == other.externalBankAccountToken && tier == other.tier && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, creditLimit, creditProductToken, externalBankAccountToken, tier, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "FinancialAccountCreditConfigurationUpdateParams{financialAccountToken=$financialAccountToken, creditLimit=$creditLimit, creditProductToken=$creditProductToken, externalBankAccountToken=$externalBankAccountToken, tier=$tier, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountListParams.kt index 6d28787b..55c44b37 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountListParams.kt @@ -28,6 +28,10 @@ constructor( fun type(): Type? = type + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -41,23 +45,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountListParams && accountToken == other.accountToken && businessAccountToken == other.businessAccountToken && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, businessAccountToken, type, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialAccountListParams{accountToken=$accountToken, businessAccountToken=$businessAccountToken, type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -75,11 +62,11 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(financialAccountListParams: FinancialAccountListParams) = apply { - this.accountToken = financialAccountListParams.accountToken - this.businessAccountToken = financialAccountListParams.businessAccountToken - this.type = financialAccountListParams.type - additionalHeaders(financialAccountListParams.additionalHeaders) - additionalQueryParams(financialAccountListParams.additionalQueryParams) + accountToken = financialAccountListParams.accountToken + businessAccountToken = financialAccountListParams.businessAccountToken + type = financialAccountListParams.type + additionalHeaders = financialAccountListParams.additionalHeaders.toBuilder() + additionalQueryParams = financialAccountListParams.additionalQueryParams.toBuilder() } /** List financial accounts for a given account_token or business_account_token */ @@ -263,4 +250,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountListParams && accountToken == other.accountToken && businessAccountToken == other.businessAccountToken && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, businessAccountToken, type, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialAccountListParams{accountToken=$accountToken, businessAccountToken=$businessAccountToken, type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountLoanTapeListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountLoanTapeListParams.kt index fec0d813..e894b4fe 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountLoanTapeListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountLoanTapeListParams.kt @@ -33,6 +33,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -53,23 +57,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountLoanTapeListParams && financialAccountToken == other.financialAccountToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, begin, end, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialAccountLoanTapeListParams{financialAccountToken=$financialAccountToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -91,15 +78,15 @@ constructor( internal fun from(financialAccountLoanTapeListParams: FinancialAccountLoanTapeListParams) = apply { - this.financialAccountToken = - financialAccountLoanTapeListParams.financialAccountToken - this.begin = financialAccountLoanTapeListParams.begin - this.end = financialAccountLoanTapeListParams.end - this.endingBefore = financialAccountLoanTapeListParams.endingBefore - this.pageSize = financialAccountLoanTapeListParams.pageSize - this.startingAfter = financialAccountLoanTapeListParams.startingAfter - additionalHeaders(financialAccountLoanTapeListParams.additionalHeaders) - additionalQueryParams(financialAccountLoanTapeListParams.additionalQueryParams) + financialAccountToken = financialAccountLoanTapeListParams.financialAccountToken + begin = financialAccountLoanTapeListParams.begin + end = financialAccountLoanTapeListParams.end + endingBefore = financialAccountLoanTapeListParams.endingBefore + pageSize = financialAccountLoanTapeListParams.pageSize + startingAfter = financialAccountLoanTapeListParams.startingAfter + additionalHeaders = financialAccountLoanTapeListParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialAccountLoanTapeListParams.additionalQueryParams.toBuilder() } /** Globally unique identifier for financial account. */ @@ -246,4 +233,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountLoanTapeListParams && financialAccountToken == other.financialAccountToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, begin, end, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialAccountLoanTapeListParams{financialAccountToken=$financialAccountToken, begin=$begin, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountLoanTapeRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountLoanTapeRetrieveParams.kt index 6934ad47..5f0143b6 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountLoanTapeRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountLoanTapeRetrieveParams.kt @@ -20,6 +20,10 @@ constructor( fun loanTapeToken(): String = loanTapeToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -32,23 +36,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountLoanTapeRetrieveParams && financialAccountToken == other.financialAccountToken && loanTapeToken == other.loanTapeToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, loanTapeToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialAccountLoanTapeRetrieveParams{financialAccountToken=$financialAccountToken, loanTapeToken=$loanTapeToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -67,11 +54,11 @@ constructor( internal fun from( financialAccountLoanTapeRetrieveParams: FinancialAccountLoanTapeRetrieveParams ) = apply { - this.financialAccountToken = - financialAccountLoanTapeRetrieveParams.financialAccountToken - this.loanTapeToken = financialAccountLoanTapeRetrieveParams.loanTapeToken - additionalHeaders(financialAccountLoanTapeRetrieveParams.additionalHeaders) - additionalQueryParams(financialAccountLoanTapeRetrieveParams.additionalQueryParams) + financialAccountToken = financialAccountLoanTapeRetrieveParams.financialAccountToken + loanTapeToken = financialAccountLoanTapeRetrieveParams.loanTapeToken + additionalHeaders = financialAccountLoanTapeRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialAccountLoanTapeRetrieveParams.additionalQueryParams.toBuilder() } /** Globally unique identifier for financial account. */ @@ -190,4 +177,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountLoanTapeRetrieveParams && financialAccountToken == other.financialAccountToken && loanTapeToken == other.loanTapeToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, loanTapeToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialAccountLoanTapeRetrieveParams{financialAccountToken=$financialAccountToken, loanTapeToken=$loanTapeToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountRetrieveParams.kt index 374f75ae..f7ced8ca 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun financialAccountToken(): String = financialAccountToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountRetrieveParams && financialAccountToken == other.financialAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialAccountRetrieveParams{financialAccountToken=$financialAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(financialAccountRetrieveParams: FinancialAccountRetrieveParams) = apply { - this.financialAccountToken = financialAccountRetrieveParams.financialAccountToken - additionalHeaders(financialAccountRetrieveParams.additionalHeaders) - additionalQueryParams(financialAccountRetrieveParams.additionalQueryParams) + financialAccountToken = financialAccountRetrieveParams.financialAccountToken + additionalHeaders = financialAccountRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = financialAccountRetrieveParams.additionalQueryParams.toBuilder() } fun financialAccountToken(financialAccountToken: String) = apply { @@ -176,4 +163,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountRetrieveParams && financialAccountToken == other.financialAccountToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialAccountRetrieveParams{financialAccountToken=$financialAccountToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementLineItemListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementLineItemListParams.kt index 21f8147a..1b120556 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementLineItemListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementLineItemListParams.kt @@ -29,6 +29,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -48,23 +52,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountStatementLineItemListParams && financialAccountToken == other.financialAccountToken && statementToken == other.statementToken && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, statementToken, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialAccountStatementLineItemListParams{financialAccountToken=$financialAccountToken, statementToken=$statementToken, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -86,14 +73,16 @@ constructor( internal fun from( financialAccountStatementLineItemListParams: FinancialAccountStatementLineItemListParams ) = apply { - this.financialAccountToken = + financialAccountToken = financialAccountStatementLineItemListParams.financialAccountToken - this.statementToken = financialAccountStatementLineItemListParams.statementToken - this.endingBefore = financialAccountStatementLineItemListParams.endingBefore - this.pageSize = financialAccountStatementLineItemListParams.pageSize - this.startingAfter = financialAccountStatementLineItemListParams.startingAfter - additionalHeaders(financialAccountStatementLineItemListParams.additionalHeaders) - additionalQueryParams(financialAccountStatementLineItemListParams.additionalQueryParams) + statementToken = financialAccountStatementLineItemListParams.statementToken + endingBefore = financialAccountStatementLineItemListParams.endingBefore + pageSize = financialAccountStatementLineItemListParams.pageSize + startingAfter = financialAccountStatementLineItemListParams.startingAfter + additionalHeaders = + financialAccountStatementLineItemListParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialAccountStatementLineItemListParams.additionalQueryParams.toBuilder() } /** Globally unique identifier for financial account. */ @@ -230,4 +219,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountStatementLineItemListParams && financialAccountToken == other.financialAccountToken && statementToken == other.statementToken && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, statementToken, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialAccountStatementLineItemListParams{financialAccountToken=$financialAccountToken, statementToken=$statementToken, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementListParams.kt index 9cccb7e1..5ead3c37 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementListParams.kt @@ -36,6 +36,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -59,23 +63,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountStatementListParams && financialAccountToken == other.financialAccountToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && includeInitialStatements == other.includeInitialStatements && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, begin, end, endingBefore, includeInitialStatements, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialAccountStatementListParams{financialAccountToken=$financialAccountToken, begin=$begin, end=$end, endingBefore=$endingBefore, includeInitialStatements=$includeInitialStatements, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -99,16 +86,16 @@ constructor( internal fun from( financialAccountStatementListParams: FinancialAccountStatementListParams ) = apply { - this.financialAccountToken = financialAccountStatementListParams.financialAccountToken - this.begin = financialAccountStatementListParams.begin - this.end = financialAccountStatementListParams.end - this.endingBefore = financialAccountStatementListParams.endingBefore - this.includeInitialStatements = - financialAccountStatementListParams.includeInitialStatements - this.pageSize = financialAccountStatementListParams.pageSize - this.startingAfter = financialAccountStatementListParams.startingAfter - additionalHeaders(financialAccountStatementListParams.additionalHeaders) - additionalQueryParams(financialAccountStatementListParams.additionalQueryParams) + financialAccountToken = financialAccountStatementListParams.financialAccountToken + begin = financialAccountStatementListParams.begin + end = financialAccountStatementListParams.end + endingBefore = financialAccountStatementListParams.endingBefore + includeInitialStatements = financialAccountStatementListParams.includeInitialStatements + pageSize = financialAccountStatementListParams.pageSize + startingAfter = financialAccountStatementListParams.startingAfter + additionalHeaders = financialAccountStatementListParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialAccountStatementListParams.additionalQueryParams.toBuilder() } /** Globally unique identifier for financial account. */ @@ -261,4 +248,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountStatementListParams && financialAccountToken == other.financialAccountToken && begin == other.begin && end == other.end && endingBefore == other.endingBefore && includeInitialStatements == other.includeInitialStatements && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, begin, end, endingBefore, includeInitialStatements, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialAccountStatementListParams{financialAccountToken=$financialAccountToken, begin=$begin, end=$end, endingBefore=$endingBefore, includeInitialStatements=$includeInitialStatements, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementRetrieveParams.kt index 02d91d54..7df4f50f 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountStatementRetrieveParams.kt @@ -20,6 +20,10 @@ constructor( fun statementToken(): String = statementToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -32,23 +36,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountStatementRetrieveParams && financialAccountToken == other.financialAccountToken && statementToken == other.statementToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, statementToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialAccountStatementRetrieveParams{financialAccountToken=$financialAccountToken, statementToken=$statementToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -67,11 +54,12 @@ constructor( internal fun from( financialAccountStatementRetrieveParams: FinancialAccountStatementRetrieveParams ) = apply { - this.financialAccountToken = - financialAccountStatementRetrieveParams.financialAccountToken - this.statementToken = financialAccountStatementRetrieveParams.statementToken - additionalHeaders(financialAccountStatementRetrieveParams.additionalHeaders) - additionalQueryParams(financialAccountStatementRetrieveParams.additionalQueryParams) + financialAccountToken = financialAccountStatementRetrieveParams.financialAccountToken + statementToken = financialAccountStatementRetrieveParams.statementToken + additionalHeaders = + financialAccountStatementRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialAccountStatementRetrieveParams.additionalQueryParams.toBuilder() } /** Globally unique identifier for financial account. */ @@ -190,4 +178,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountStatementRetrieveParams && financialAccountToken == other.financialAccountToken && statementToken == other.statementToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, statementToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialAccountStatementRetrieveParams{financialAccountToken=$financialAccountToken, statementToken=$statementToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountUpdateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountUpdateParams.kt index b9e60d06..1ea93cbb 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountUpdateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialAccountUpdateParams.kt @@ -28,6 +28,12 @@ constructor( fun nickname(): String? = nickname + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): FinancialAccountUpdateBody { return FinancialAccountUpdateBody(nickname, additionalBodyProperties) } @@ -113,25 +119,6 @@ constructor( "FinancialAccountUpdateBody{nickname=$nickname, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialAccountUpdateParams && financialAccountToken == other.financialAccountToken && nickname == other.nickname && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, nickname, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "FinancialAccountUpdateParams{financialAccountToken=$financialAccountToken, nickname=$nickname, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -149,11 +136,12 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(financialAccountUpdateParams: FinancialAccountUpdateParams) = apply { - this.financialAccountToken = financialAccountUpdateParams.financialAccountToken - this.nickname = financialAccountUpdateParams.nickname - additionalHeaders(financialAccountUpdateParams.additionalHeaders) - additionalQueryParams(financialAccountUpdateParams.additionalQueryParams) - additionalBodyProperties(financialAccountUpdateParams.additionalBodyProperties) + financialAccountToken = financialAccountUpdateParams.financialAccountToken + nickname = financialAccountUpdateParams.nickname + additionalHeaders = financialAccountUpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = financialAccountUpdateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + financialAccountUpdateParams.additionalBodyProperties.toMutableMap() } fun financialAccountToken(financialAccountToken: String) = apply { @@ -293,4 +281,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialAccountUpdateParams && financialAccountToken == other.financialAccountToken && nickname == other.nickname && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, nickname, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "FinancialAccountUpdateParams{financialAccountToken=$financialAccountToken, nickname=$nickname, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialTransactionListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialTransactionListParams.kt index f0e4faba..5d79bdb3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialTransactionListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialTransactionListParams.kt @@ -45,6 +45,10 @@ constructor( fun status(): Status? = status + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -71,23 +75,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialTransactionListParams && financialAccountToken == other.financialAccountToken && begin == other.begin && category == other.category && end == other.end && endingBefore == other.endingBefore && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, begin, category, end, endingBefore, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialTransactionListParams{financialAccountToken=$financialAccountToken, begin=$begin, category=$category, end=$end, endingBefore=$endingBefore, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -110,16 +97,16 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(financialTransactionListParams: FinancialTransactionListParams) = apply { - this.financialAccountToken = financialTransactionListParams.financialAccountToken - this.begin = financialTransactionListParams.begin - this.category = financialTransactionListParams.category - this.end = financialTransactionListParams.end - this.endingBefore = financialTransactionListParams.endingBefore - this.result = financialTransactionListParams.result - this.startingAfter = financialTransactionListParams.startingAfter - this.status = financialTransactionListParams.status - additionalHeaders(financialTransactionListParams.additionalHeaders) - additionalQueryParams(financialTransactionListParams.additionalQueryParams) + financialAccountToken = financialTransactionListParams.financialAccountToken + begin = financialTransactionListParams.begin + category = financialTransactionListParams.category + end = financialTransactionListParams.end + endingBefore = financialTransactionListParams.endingBefore + result = financialTransactionListParams.result + startingAfter = financialTransactionListParams.startingAfter + status = financialTransactionListParams.status + additionalHeaders = financialTransactionListParams.additionalHeaders.toBuilder() + additionalQueryParams = financialTransactionListParams.additionalQueryParams.toBuilder() } fun financialAccountToken(financialAccountToken: String) = apply { @@ -474,4 +461,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialTransactionListParams && financialAccountToken == other.financialAccountToken && begin == other.begin && category == other.category && end == other.end && endingBefore == other.endingBefore && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, begin, category, end, endingBefore, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialTransactionListParams{financialAccountToken=$financialAccountToken, begin=$begin, category=$category, end=$end, endingBefore=$endingBefore, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialTransactionRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialTransactionRetrieveParams.kt index 228f00aa..46374a95 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialTransactionRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/FinancialTransactionRetrieveParams.kt @@ -20,6 +20,10 @@ constructor( fun financialTransactionToken(): String = financialTransactionToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -32,23 +36,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is FinancialTransactionRetrieveParams && financialAccountToken == other.financialAccountToken && financialTransactionToken == other.financialTransactionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, financialTransactionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "FinancialTransactionRetrieveParams{financialAccountToken=$financialAccountToken, financialTransactionToken=$financialTransactionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -66,12 +53,12 @@ constructor( internal fun from(financialTransactionRetrieveParams: FinancialTransactionRetrieveParams) = apply { - this.financialAccountToken = - financialTransactionRetrieveParams.financialAccountToken - this.financialTransactionToken = + financialAccountToken = financialTransactionRetrieveParams.financialAccountToken + financialTransactionToken = financialTransactionRetrieveParams.financialTransactionToken - additionalHeaders(financialTransactionRetrieveParams.additionalHeaders) - additionalQueryParams(financialTransactionRetrieveParams.additionalQueryParams) + additionalHeaders = financialTransactionRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + financialTransactionRetrieveParams.additionalQueryParams.toBuilder() } fun financialAccountToken(financialAccountToken: String) = apply { @@ -192,4 +179,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is FinancialTransactionRetrieveParams && financialAccountToken == other.financialAccountToken && financialTransactionToken == other.financialTransactionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(financialAccountToken, financialTransactionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "FinancialTransactionRetrieveParams{financialAccountToken=$financialAccountToken, financialTransactionToken=$financialTransactionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationCreateParams.kt index a77e10a3..153a1b6e 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationCreateParams.kt @@ -57,6 +57,12 @@ constructor( fun userDefinedId(): String? = userDefinedId + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ManagementOperationCreateBody { return ManagementOperationCreateBody( amount, @@ -239,25 +245,6 @@ constructor( "ManagementOperationCreateBody{amount=$amount, category=$category, direction=$direction, effectiveDate=$effectiveDate, eventType=$eventType, financialAccountToken=$financialAccountToken, token=$token, memo=$memo, subtype=$subtype, userDefinedId=$userDefinedId, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ManagementOperationCreateParams && amount == other.amount && category == other.category && direction == other.direction && effectiveDate == other.effectiveDate && eventType == other.eventType && financialAccountToken == other.financialAccountToken && token == other.token && memo == other.memo && subtype == other.subtype && userDefinedId == other.userDefinedId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, category, direction, effectiveDate, eventType, financialAccountToken, token, memo, subtype, userDefinedId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ManagementOperationCreateParams{amount=$amount, category=$category, direction=$direction, effectiveDate=$effectiveDate, eventType=$eventType, financialAccountToken=$financialAccountToken, token=$token, memo=$memo, subtype=$subtype, userDefinedId=$userDefinedId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -284,19 +271,21 @@ constructor( internal fun from(managementOperationCreateParams: ManagementOperationCreateParams) = apply { - this.amount = managementOperationCreateParams.amount - this.category = managementOperationCreateParams.category - this.direction = managementOperationCreateParams.direction - this.effectiveDate = managementOperationCreateParams.effectiveDate - this.eventType = managementOperationCreateParams.eventType - this.financialAccountToken = managementOperationCreateParams.financialAccountToken - this.token = managementOperationCreateParams.token - this.memo = managementOperationCreateParams.memo - this.subtype = managementOperationCreateParams.subtype - this.userDefinedId = managementOperationCreateParams.userDefinedId - additionalHeaders(managementOperationCreateParams.additionalHeaders) - additionalQueryParams(managementOperationCreateParams.additionalQueryParams) - additionalBodyProperties(managementOperationCreateParams.additionalBodyProperties) + amount = managementOperationCreateParams.amount + category = managementOperationCreateParams.category + direction = managementOperationCreateParams.direction + effectiveDate = managementOperationCreateParams.effectiveDate + eventType = managementOperationCreateParams.eventType + financialAccountToken = managementOperationCreateParams.financialAccountToken + token = managementOperationCreateParams.token + memo = managementOperationCreateParams.memo + subtype = managementOperationCreateParams.subtype + userDefinedId = managementOperationCreateParams.userDefinedId + additionalHeaders = managementOperationCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = + managementOperationCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + managementOperationCreateParams.additionalBodyProperties.toMutableMap() } fun amount(amount: Long) = apply { this.amount = amount } @@ -718,4 +707,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ManagementOperationCreateParams && amount == other.amount && category == other.category && direction == other.direction && effectiveDate == other.effectiveDate && eventType == other.eventType && financialAccountToken == other.financialAccountToken && token == other.token && memo == other.memo && subtype == other.subtype && userDefinedId == other.userDefinedId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, category, direction, effectiveDate, eventType, financialAccountToken, token, memo, subtype, userDefinedId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ManagementOperationCreateParams{amount=$amount, category=$category, direction=$direction, effectiveDate=$effectiveDate, eventType=$eventType, financialAccountToken=$financialAccountToken, token=$token, memo=$memo, subtype=$subtype, userDefinedId=$userDefinedId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationListParams.kt index 1a865e96..7dc6865a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationListParams.kt @@ -48,6 +48,10 @@ constructor( fun status(): TransactionStatus? = status + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -73,23 +77,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ManagementOperationListParams && begin == other.begin && businessAccountToken == other.businessAccountToken && category == other.category && end == other.end && endingBefore == other.endingBefore && financialAccountToken == other.financialAccountToken && pageSize == other.pageSize && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, businessAccountToken, category, end, endingBefore, financialAccountToken, pageSize, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ManagementOperationListParams{begin=$begin, businessAccountToken=$businessAccountToken, category=$category, end=$end, endingBefore=$endingBefore, financialAccountToken=$financialAccountToken, pageSize=$pageSize, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -113,17 +100,17 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(managementOperationListParams: ManagementOperationListParams) = apply { - this.begin = managementOperationListParams.begin - this.businessAccountToken = managementOperationListParams.businessAccountToken - this.category = managementOperationListParams.category - this.end = managementOperationListParams.end - this.endingBefore = managementOperationListParams.endingBefore - this.financialAccountToken = managementOperationListParams.financialAccountToken - this.pageSize = managementOperationListParams.pageSize - this.startingAfter = managementOperationListParams.startingAfter - this.status = managementOperationListParams.status - additionalHeaders(managementOperationListParams.additionalHeaders) - additionalQueryParams(managementOperationListParams.additionalQueryParams) + begin = managementOperationListParams.begin + businessAccountToken = managementOperationListParams.businessAccountToken + category = managementOperationListParams.category + end = managementOperationListParams.end + endingBefore = managementOperationListParams.endingBefore + financialAccountToken = managementOperationListParams.financialAccountToken + pageSize = managementOperationListParams.pageSize + startingAfter = managementOperationListParams.startingAfter + status = managementOperationListParams.status + additionalHeaders = managementOperationListParams.additionalHeaders.toBuilder() + additionalQueryParams = managementOperationListParams.additionalQueryParams.toBuilder() } /** @@ -430,4 +417,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ManagementOperationListParams && begin == other.begin && businessAccountToken == other.businessAccountToken && category == other.category && end == other.end && endingBefore == other.endingBefore && financialAccountToken == other.financialAccountToken && pageSize == other.pageSize && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(begin, businessAccountToken, category, end, endingBefore, financialAccountToken, pageSize, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ManagementOperationListParams{begin=$begin, businessAccountToken=$businessAccountToken, category=$category, end=$end, endingBefore=$endingBefore, financialAccountToken=$financialAccountToken, pageSize=$pageSize, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationRetrieveParams.kt index 848fea09..f0c74aec 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun managementOperationToken(): String = managementOperationToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ManagementOperationRetrieveParams && managementOperationToken == other.managementOperationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(managementOperationToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ManagementOperationRetrieveParams{managementOperationToken=$managementOperationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -61,10 +48,11 @@ constructor( internal fun from(managementOperationRetrieveParams: ManagementOperationRetrieveParams) = apply { - this.managementOperationToken = + managementOperationToken = managementOperationRetrieveParams.managementOperationToken - additionalHeaders(managementOperationRetrieveParams.additionalHeaders) - additionalQueryParams(managementOperationRetrieveParams.additionalQueryParams) + additionalHeaders = managementOperationRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + managementOperationRetrieveParams.additionalQueryParams.toBuilder() } fun managementOperationToken(managementOperationToken: String) = apply { @@ -178,4 +166,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ManagementOperationRetrieveParams && managementOperationToken == other.managementOperationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(managementOperationToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ManagementOperationRetrieveParams{managementOperationToken=$managementOperationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationReverseParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationReverseParams.kt index b4c9dd7c..1c6758b6 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationReverseParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ManagementOperationReverseParams.kt @@ -32,6 +32,12 @@ constructor( fun memo(): String? = memo + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ManagementOperationReverseBody { return ManagementOperationReverseBody( effectiveDate, @@ -135,25 +141,6 @@ constructor( "ManagementOperationReverseBody{effectiveDate=$effectiveDate, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ManagementOperationReverseParams && managementOperationToken == other.managementOperationToken && effectiveDate == other.effectiveDate && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(managementOperationToken, effectiveDate, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ManagementOperationReverseParams{managementOperationToken=$managementOperationToken, effectiveDate=$effectiveDate, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -173,13 +160,14 @@ constructor( internal fun from(managementOperationReverseParams: ManagementOperationReverseParams) = apply { - this.managementOperationToken = - managementOperationReverseParams.managementOperationToken - this.effectiveDate = managementOperationReverseParams.effectiveDate - this.memo = managementOperationReverseParams.memo - additionalHeaders(managementOperationReverseParams.additionalHeaders) - additionalQueryParams(managementOperationReverseParams.additionalQueryParams) - additionalBodyProperties(managementOperationReverseParams.additionalBodyProperties) + managementOperationToken = managementOperationReverseParams.managementOperationToken + effectiveDate = managementOperationReverseParams.effectiveDate + memo = managementOperationReverseParams.memo + additionalHeaders = managementOperationReverseParams.additionalHeaders.toBuilder() + additionalQueryParams = + managementOperationReverseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + managementOperationReverseParams.additionalBodyProperties.toMutableMap() } fun managementOperationToken(managementOperationToken: String) = apply { @@ -322,4 +310,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ManagementOperationReverseParams && managementOperationToken == other.managementOperationToken && effectiveDate == other.effectiveDate && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(managementOperationToken, effectiveDate, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ManagementOperationReverseParams{managementOperationToken=$managementOperationToken, effectiveDate=$effectiveDate, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentCreateParams.kt index b59085ae..105bb5ca 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentCreateParams.kt @@ -53,6 +53,12 @@ constructor( fun userDefinedId(): String? = userDefinedId + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): PaymentCreateBody { return PaymentCreateBody( amount, @@ -235,25 +241,6 @@ constructor( "PaymentCreateBody{amount=$amount, externalBankAccountToken=$externalBankAccountToken, financialAccountToken=$financialAccountToken, method=$method, methodAttributes=$methodAttributes, type=$type, token=$token, memo=$memo, userDefinedId=$userDefinedId, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is PaymentCreateParams && amount == other.amount && externalBankAccountToken == other.externalBankAccountToken && financialAccountToken == other.financialAccountToken && method == other.method && methodAttributes == other.methodAttributes && type == other.type && token == other.token && memo == other.memo && userDefinedId == other.userDefinedId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, externalBankAccountToken, financialAccountToken, method, methodAttributes, type, token, memo, userDefinedId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "PaymentCreateParams{amount=$amount, externalBankAccountToken=$externalBankAccountToken, financialAccountToken=$financialAccountToken, method=$method, methodAttributes=$methodAttributes, type=$type, token=$token, memo=$memo, userDefinedId=$userDefinedId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -278,18 +265,18 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentCreateParams: PaymentCreateParams) = apply { - this.amount = paymentCreateParams.amount - this.externalBankAccountToken = paymentCreateParams.externalBankAccountToken - this.financialAccountToken = paymentCreateParams.financialAccountToken - this.method = paymentCreateParams.method - this.methodAttributes = paymentCreateParams.methodAttributes - this.type = paymentCreateParams.type - this.token = paymentCreateParams.token - this.memo = paymentCreateParams.memo - this.userDefinedId = paymentCreateParams.userDefinedId - additionalHeaders(paymentCreateParams.additionalHeaders) - additionalQueryParams(paymentCreateParams.additionalQueryParams) - additionalBodyProperties(paymentCreateParams.additionalBodyProperties) + amount = paymentCreateParams.amount + externalBankAccountToken = paymentCreateParams.externalBankAccountToken + financialAccountToken = paymentCreateParams.financialAccountToken + method = paymentCreateParams.method + methodAttributes = paymentCreateParams.methodAttributes + type = paymentCreateParams.type + token = paymentCreateParams.token + memo = paymentCreateParams.memo + userDefinedId = paymentCreateParams.userDefinedId + additionalHeaders = paymentCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = paymentCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = paymentCreateParams.additionalBodyProperties.toMutableMap() } fun amount(amount: Long) = apply { this.amount = amount } @@ -711,4 +698,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is PaymentCreateParams && amount == other.amount && externalBankAccountToken == other.externalBankAccountToken && financialAccountToken == other.financialAccountToken && method == other.method && methodAttributes == other.methodAttributes && type == other.type && token == other.token && memo == other.memo && userDefinedId == other.userDefinedId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, externalBankAccountToken, financialAccountToken, method, methodAttributes, type, token, memo, userDefinedId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "PaymentCreateParams{amount=$amount, externalBankAccountToken=$externalBankAccountToken, financialAccountToken=$financialAccountToken, method=$method, methodAttributes=$methodAttributes, type=$type, token=$token, memo=$memo, userDefinedId=$userDefinedId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentListParams.kt index 918fb216..8cf4a162 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentListParams.kt @@ -54,6 +54,10 @@ constructor( fun status(): Status? = status + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -81,23 +85,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is PaymentListParams && accountToken == other.accountToken && begin == other.begin && businessAccountToken == other.businessAccountToken && category == other.category && end == other.end && endingBefore == other.endingBefore && financialAccountToken == other.financialAccountToken && pageSize == other.pageSize && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, businessAccountToken, category, end, endingBefore, financialAccountToken, pageSize, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "PaymentListParams{accountToken=$accountToken, begin=$begin, businessAccountToken=$businessAccountToken, category=$category, end=$end, endingBefore=$endingBefore, financialAccountToken=$financialAccountToken, pageSize=$pageSize, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -123,19 +110,19 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(paymentListParams: PaymentListParams) = apply { - this.accountToken = paymentListParams.accountToken - this.begin = paymentListParams.begin - this.businessAccountToken = paymentListParams.businessAccountToken - this.category = paymentListParams.category - this.end = paymentListParams.end - this.endingBefore = paymentListParams.endingBefore - this.financialAccountToken = paymentListParams.financialAccountToken - this.pageSize = paymentListParams.pageSize - this.result = paymentListParams.result - this.startingAfter = paymentListParams.startingAfter - this.status = paymentListParams.status - additionalHeaders(paymentListParams.additionalHeaders) - additionalQueryParams(paymentListParams.additionalQueryParams) + accountToken = paymentListParams.accountToken + begin = paymentListParams.begin + businessAccountToken = paymentListParams.businessAccountToken + category = paymentListParams.category + end = paymentListParams.end + endingBefore = paymentListParams.endingBefore + financialAccountToken = paymentListParams.financialAccountToken + pageSize = paymentListParams.pageSize + result = paymentListParams.result + startingAfter = paymentListParams.startingAfter + status = paymentListParams.status + additionalHeaders = paymentListParams.additionalHeaders.toBuilder() + additionalQueryParams = paymentListParams.additionalQueryParams.toBuilder() } fun accountToken(accountToken: String) = apply { this.accountToken = accountToken } @@ -473,4 +460,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is PaymentListParams && accountToken == other.accountToken && begin == other.begin && businessAccountToken == other.businessAccountToken && category == other.category && end == other.end && endingBefore == other.endingBefore && financialAccountToken == other.financialAccountToken && pageSize == other.pageSize && result == other.result && startingAfter == other.startingAfter && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, businessAccountToken, category, end, endingBefore, financialAccountToken, pageSize, result, startingAfter, status, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "PaymentListParams{accountToken=$accountToken, begin=$begin, businessAccountToken=$businessAccountToken, category=$category, end=$end, endingBefore=$endingBefore, financialAccountToken=$financialAccountToken, pageSize=$pageSize, result=$result, startingAfter=$startingAfter, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentRetrieveParams.kt index 424d0d6a..03926aa8 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun paymentToken(): String = paymentToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is PaymentRetrieveParams && paymentToken == other.paymentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "PaymentRetrieveParams{paymentToken=$paymentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(paymentRetrieveParams: PaymentRetrieveParams) = apply { - this.paymentToken = paymentRetrieveParams.paymentToken - additionalHeaders(paymentRetrieveParams.additionalHeaders) - additionalQueryParams(paymentRetrieveParams.additionalQueryParams) + paymentToken = paymentRetrieveParams.paymentToken + additionalHeaders = paymentRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = paymentRetrieveParams.additionalQueryParams.toBuilder() } fun paymentToken(paymentToken: String) = apply { this.paymentToken = paymentToken } @@ -172,4 +159,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is PaymentRetrieveParams && paymentToken == other.paymentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "PaymentRetrieveParams{paymentToken=$paymentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentRetryParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentRetryParams.kt index 2b9a37cb..2e296ccb 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentRetryParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentRetryParams.kt @@ -20,6 +20,12 @@ constructor( fun paymentToken(): String = paymentToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is PaymentRetryParams && paymentToken == other.paymentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "PaymentRetryParams{paymentToken=$paymentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -70,10 +57,10 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentRetryParams: PaymentRetryParams) = apply { - this.paymentToken = paymentRetryParams.paymentToken - additionalHeaders(paymentRetryParams.additionalHeaders) - additionalQueryParams(paymentRetryParams.additionalQueryParams) - additionalBodyProperties(paymentRetryParams.additionalBodyProperties) + paymentToken = paymentRetryParams.paymentToken + additionalHeaders = paymentRetryParams.additionalHeaders.toBuilder() + additionalQueryParams = paymentRetryParams.additionalQueryParams.toBuilder() + additionalBodyProperties = paymentRetryParams.additionalBodyProperties.toMutableMap() } fun paymentToken(paymentToken: String) = apply { this.paymentToken = paymentToken } @@ -206,4 +193,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is PaymentRetryParams && paymentToken == other.paymentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "PaymentRetryParams{paymentToken=$paymentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateActionParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateActionParams.kt index 607e8bbc..8e1c79fe 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateActionParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateActionParams.kt @@ -38,6 +38,12 @@ constructor( fun returnReasonCode(): String? = returnReasonCode + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): PaymentSimulateActionBody { return PaymentSimulateActionBody( eventType, @@ -162,25 +168,6 @@ constructor( "PaymentSimulateActionBody{eventType=$eventType, declineReason=$declineReason, returnReasonCode=$returnReasonCode, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is PaymentSimulateActionParams && paymentToken == other.paymentToken && eventType == other.eventType && declineReason == other.declineReason && returnReasonCode == other.returnReasonCode && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, eventType, declineReason, returnReasonCode, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "PaymentSimulateActionParams{paymentToken=$paymentToken, eventType=$eventType, declineReason=$declineReason, returnReasonCode=$returnReasonCode, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -200,13 +187,14 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentSimulateActionParams: PaymentSimulateActionParams) = apply { - this.paymentToken = paymentSimulateActionParams.paymentToken - this.eventType = paymentSimulateActionParams.eventType - this.declineReason = paymentSimulateActionParams.declineReason - this.returnReasonCode = paymentSimulateActionParams.returnReasonCode - additionalHeaders(paymentSimulateActionParams.additionalHeaders) - additionalQueryParams(paymentSimulateActionParams.additionalQueryParams) - additionalBodyProperties(paymentSimulateActionParams.additionalBodyProperties) + paymentToken = paymentSimulateActionParams.paymentToken + eventType = paymentSimulateActionParams.eventType + declineReason = paymentSimulateActionParams.declineReason + returnReasonCode = paymentSimulateActionParams.returnReasonCode + additionalHeaders = paymentSimulateActionParams.additionalHeaders.toBuilder() + additionalQueryParams = paymentSimulateActionParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + paymentSimulateActionParams.additionalBodyProperties.toMutableMap() } fun paymentToken(paymentToken: String) = apply { this.paymentToken = paymentToken } @@ -519,4 +507,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is PaymentSimulateActionParams && paymentToken == other.paymentToken && eventType == other.eventType && declineReason == other.declineReason && returnReasonCode == other.returnReasonCode && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, eventType, declineReason, returnReasonCode, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "PaymentSimulateActionParams{paymentToken=$paymentToken, eventType=$eventType, declineReason=$declineReason, returnReasonCode=$returnReasonCode, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReceiptParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReceiptParams.kt index d58e2714..a0917f11 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReceiptParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReceiptParams.kt @@ -41,6 +41,12 @@ constructor( fun memo(): String? = memo + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): PaymentSimulateReceiptBody { return PaymentSimulateReceiptBody( token, @@ -177,25 +183,6 @@ constructor( "PaymentSimulateReceiptBody{token=$token, amount=$amount, financialAccountToken=$financialAccountToken, receiptType=$receiptType, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is PaymentSimulateReceiptParams && token == other.token && amount == other.amount && financialAccountToken == other.financialAccountToken && receiptType == other.receiptType && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, amount, financialAccountToken, receiptType, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "PaymentSimulateReceiptParams{token=$token, amount=$amount, financialAccountToken=$financialAccountToken, receiptType=$receiptType, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -216,14 +203,15 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentSimulateReceiptParams: PaymentSimulateReceiptParams) = apply { - this.token = paymentSimulateReceiptParams.token - this.amount = paymentSimulateReceiptParams.amount - this.financialAccountToken = paymentSimulateReceiptParams.financialAccountToken - this.receiptType = paymentSimulateReceiptParams.receiptType - this.memo = paymentSimulateReceiptParams.memo - additionalHeaders(paymentSimulateReceiptParams.additionalHeaders) - additionalQueryParams(paymentSimulateReceiptParams.additionalQueryParams) - additionalBodyProperties(paymentSimulateReceiptParams.additionalBodyProperties) + token = paymentSimulateReceiptParams.token + amount = paymentSimulateReceiptParams.amount + financialAccountToken = paymentSimulateReceiptParams.financialAccountToken + receiptType = paymentSimulateReceiptParams.receiptType + memo = paymentSimulateReceiptParams.memo + additionalHeaders = paymentSimulateReceiptParams.additionalHeaders.toBuilder() + additionalQueryParams = paymentSimulateReceiptParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + paymentSimulateReceiptParams.additionalBodyProperties.toMutableMap() } /** Payment token */ @@ -434,4 +422,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is PaymentSimulateReceiptParams && token == other.token && amount == other.amount && financialAccountToken == other.financialAccountToken && receiptType == other.receiptType && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, amount, financialAccountToken, receiptType, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "PaymentSimulateReceiptParams{token=$token, amount=$amount, financialAccountToken=$financialAccountToken, receiptType=$receiptType, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReleaseParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReleaseParams.kt index dac9da76..19fdc725 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReleaseParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReleaseParams.kt @@ -25,6 +25,12 @@ constructor( fun paymentToken(): String = paymentToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): PaymentSimulateReleaseBody { return PaymentSimulateReleaseBody(paymentToken, additionalBodyProperties) } @@ -108,25 +114,6 @@ constructor( "PaymentSimulateReleaseBody{paymentToken=$paymentToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is PaymentSimulateReleaseParams && paymentToken == other.paymentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "PaymentSimulateReleaseParams{paymentToken=$paymentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -143,10 +130,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentSimulateReleaseParams: PaymentSimulateReleaseParams) = apply { - this.paymentToken = paymentSimulateReleaseParams.paymentToken - additionalHeaders(paymentSimulateReleaseParams.additionalHeaders) - additionalQueryParams(paymentSimulateReleaseParams.additionalQueryParams) - additionalBodyProperties(paymentSimulateReleaseParams.additionalBodyProperties) + paymentToken = paymentSimulateReleaseParams.paymentToken + additionalHeaders = paymentSimulateReleaseParams.additionalHeaders.toBuilder() + additionalQueryParams = paymentSimulateReleaseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + paymentSimulateReleaseParams.additionalBodyProperties.toMutableMap() } /** Payment Token */ @@ -280,4 +268,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is PaymentSimulateReleaseParams && paymentToken == other.paymentToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "PaymentSimulateReleaseParams{paymentToken=$paymentToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReturnParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReturnParams.kt index 55d8ddf6..31581cc7 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReturnParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/PaymentSimulateReturnParams.kt @@ -28,6 +28,12 @@ constructor( fun returnReasonCode(): String? = returnReasonCode + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): PaymentSimulateReturnBody { return PaymentSimulateReturnBody( paymentToken, @@ -128,25 +134,6 @@ constructor( "PaymentSimulateReturnBody{paymentToken=$paymentToken, returnReasonCode=$returnReasonCode, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is PaymentSimulateReturnParams && paymentToken == other.paymentToken && returnReasonCode == other.returnReasonCode && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, returnReasonCode, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "PaymentSimulateReturnParams{paymentToken=$paymentToken, returnReasonCode=$returnReasonCode, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -164,11 +151,12 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentSimulateReturnParams: PaymentSimulateReturnParams) = apply { - this.paymentToken = paymentSimulateReturnParams.paymentToken - this.returnReasonCode = paymentSimulateReturnParams.returnReasonCode - additionalHeaders(paymentSimulateReturnParams.additionalHeaders) - additionalQueryParams(paymentSimulateReturnParams.additionalQueryParams) - additionalBodyProperties(paymentSimulateReturnParams.additionalBodyProperties) + paymentToken = paymentSimulateReturnParams.paymentToken + returnReasonCode = paymentSimulateReturnParams.returnReasonCode + additionalHeaders = paymentSimulateReturnParams.additionalHeaders.toBuilder() + additionalQueryParams = paymentSimulateReturnParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + paymentSimulateReturnParams.additionalBodyProperties.toMutableMap() } /** Payment Token */ @@ -308,4 +296,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is PaymentSimulateReturnParams && paymentToken == other.paymentToken && returnReasonCode == other.returnReasonCode && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(paymentToken, returnReasonCode, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "PaymentSimulateReturnParams{paymentToken=$paymentToken, returnReasonCode=$returnReasonCode, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ReportSettlementListDetailsParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ReportSettlementListDetailsParams.kt index 48e7f1e0..859b234c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ReportSettlementListDetailsParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ReportSettlementListDetailsParams.kt @@ -27,6 +27,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -45,23 +49,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ReportSettlementListDetailsParams && reportDate == other.reportDate && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(reportDate, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ReportSettlementListDetailsParams{reportDate=$reportDate, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -81,12 +68,13 @@ constructor( internal fun from(reportSettlementListDetailsParams: ReportSettlementListDetailsParams) = apply { - this.reportDate = reportSettlementListDetailsParams.reportDate - this.endingBefore = reportSettlementListDetailsParams.endingBefore - this.pageSize = reportSettlementListDetailsParams.pageSize - this.startingAfter = reportSettlementListDetailsParams.startingAfter - additionalHeaders(reportSettlementListDetailsParams.additionalHeaders) - additionalQueryParams(reportSettlementListDetailsParams.additionalQueryParams) + reportDate = reportSettlementListDetailsParams.reportDate + endingBefore = reportSettlementListDetailsParams.endingBefore + pageSize = reportSettlementListDetailsParams.pageSize + startingAfter = reportSettlementListDetailsParams.startingAfter + additionalHeaders = reportSettlementListDetailsParams.additionalHeaders.toBuilder() + additionalQueryParams = + reportSettlementListDetailsParams.additionalQueryParams.toBuilder() } fun reportDate(reportDate: LocalDate) = apply { this.reportDate = reportDate } @@ -214,4 +202,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ReportSettlementListDetailsParams && reportDate == other.reportDate && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(reportDate, endingBefore, pageSize, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ReportSettlementListDetailsParams{reportDate=$reportDate, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ReportSettlementSummaryParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ReportSettlementSummaryParams.kt index aaab73c1..aeb67e44 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ReportSettlementSummaryParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ReportSettlementSummaryParams.kt @@ -18,6 +18,10 @@ constructor( fun reportDate(): LocalDate = reportDate + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -29,23 +33,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ReportSettlementSummaryParams && reportDate == other.reportDate && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(reportDate, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ReportSettlementSummaryParams{reportDate=$reportDate, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -61,9 +48,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(reportSettlementSummaryParams: ReportSettlementSummaryParams) = apply { - this.reportDate = reportSettlementSummaryParams.reportDate - additionalHeaders(reportSettlementSummaryParams.additionalHeaders) - additionalQueryParams(reportSettlementSummaryParams.additionalQueryParams) + reportDate = reportSettlementSummaryParams.reportDate + additionalHeaders = reportSettlementSummaryParams.additionalHeaders.toBuilder() + additionalQueryParams = reportSettlementSummaryParams.additionalQueryParams.toBuilder() } fun reportDate(reportDate: LocalDate) = apply { this.reportDate = reportDate } @@ -173,4 +160,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ReportSettlementSummaryParams && reportDate == other.reportDate && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(reportDate, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ReportSettlementSummaryParams{reportDate=$reportDate, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointCheckStatusParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointCheckStatusParams.kt index 5997345d..8d9a3641 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointCheckStatusParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointCheckStatusParams.kt @@ -22,6 +22,10 @@ constructor( fun type(): Type = type + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -31,23 +35,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ResponderEndpointCheckStatusParams && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(type, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ResponderEndpointCheckStatusParams{type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -64,9 +51,10 @@ constructor( internal fun from(responderEndpointCheckStatusParams: ResponderEndpointCheckStatusParams) = apply { - this.type = responderEndpointCheckStatusParams.type - additionalHeaders(responderEndpointCheckStatusParams.additionalHeaders) - additionalQueryParams(responderEndpointCheckStatusParams.additionalQueryParams) + type = responderEndpointCheckStatusParams.type + additionalHeaders = responderEndpointCheckStatusParams.additionalHeaders.toBuilder() + additionalQueryParams = + responderEndpointCheckStatusParams.additionalQueryParams.toBuilder() } /** The type of the endpoint. */ @@ -240,4 +228,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ResponderEndpointCheckStatusParams && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(type, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ResponderEndpointCheckStatusParams{type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointCreateParams.kt index fce1582c..3515e18c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointCreateParams.kt @@ -32,6 +32,12 @@ constructor( fun url(): String? = url + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ResponderEndpointCreateBody { return ResponderEndpointCreateBody( type, @@ -128,25 +134,6 @@ constructor( "ResponderEndpointCreateBody{type=$type, url=$url, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ResponderEndpointCreateParams && type == other.type && url == other.url && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(type, url, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ResponderEndpointCreateParams{type=$type, url=$url, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -164,11 +151,12 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(responderEndpointCreateParams: ResponderEndpointCreateParams) = apply { - this.type = responderEndpointCreateParams.type - this.url = responderEndpointCreateParams.url - additionalHeaders(responderEndpointCreateParams.additionalHeaders) - additionalQueryParams(responderEndpointCreateParams.additionalQueryParams) - additionalBodyProperties(responderEndpointCreateParams.additionalBodyProperties) + type = responderEndpointCreateParams.type + url = responderEndpointCreateParams.url + additionalHeaders = responderEndpointCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = responderEndpointCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + responderEndpointCreateParams.additionalBodyProperties.toMutableMap() } /** The type of the endpoint. */ @@ -369,4 +357,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ResponderEndpointCreateParams && type == other.type && url == other.url && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(type, url, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ResponderEndpointCreateParams{type=$type, url=$url, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointDeleteParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointDeleteParams.kt index eb58eeeb..57428c1a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointDeleteParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ResponderEndpointDeleteParams.kt @@ -24,6 +24,12 @@ constructor( fun type(): Type = type + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -37,25 +43,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ResponderEndpointDeleteParams && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(type, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ResponderEndpointDeleteParams{type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -72,10 +59,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(responderEndpointDeleteParams: ResponderEndpointDeleteParams) = apply { - this.type = responderEndpointDeleteParams.type - additionalHeaders(responderEndpointDeleteParams.additionalHeaders) - additionalQueryParams(responderEndpointDeleteParams.additionalQueryParams) - additionalBodyProperties(responderEndpointDeleteParams.additionalBodyProperties) + type = responderEndpointDeleteParams.type + additionalHeaders = responderEndpointDeleteParams.additionalHeaders.toBuilder() + additionalQueryParams = responderEndpointDeleteParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + responderEndpointDeleteParams.additionalBodyProperties.toMutableMap() } /** The type of the endpoint. */ @@ -272,4 +260,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ResponderEndpointDeleteParams && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(type, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ResponderEndpointDeleteParams{type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSAuthenticationRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSAuthenticationRetrieveParams.kt index e6f2f9b9..06bd7ce9 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSAuthenticationRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSAuthenticationRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun threeDSAuthenticationToken(): String = threeDSAuthenticationToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ThreeDSAuthenticationRetrieveParams && threeDSAuthenticationToken == other.threeDSAuthenticationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(threeDSAuthenticationToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "ThreeDSAuthenticationRetrieveParams{threeDSAuthenticationToken=$threeDSAuthenticationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -62,10 +49,11 @@ constructor( internal fun from( threeDSAuthenticationRetrieveParams: ThreeDSAuthenticationRetrieveParams ) = apply { - this.threeDSAuthenticationToken = + threeDSAuthenticationToken = threeDSAuthenticationRetrieveParams.threeDSAuthenticationToken - additionalHeaders(threeDSAuthenticationRetrieveParams.additionalHeaders) - additionalQueryParams(threeDSAuthenticationRetrieveParams.additionalQueryParams) + additionalHeaders = threeDSAuthenticationRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + threeDSAuthenticationRetrieveParams.additionalQueryParams.toBuilder() } fun threeDSAuthenticationToken(threeDSAuthenticationToken: String) = apply { @@ -179,4 +167,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ThreeDSAuthenticationRetrieveParams && threeDSAuthenticationToken == other.threeDSAuthenticationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(threeDSAuthenticationToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ThreeDSAuthenticationRetrieveParams{threeDSAuthenticationToken=$threeDSAuthenticationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSAuthenticationSimulateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSAuthenticationSimulateParams.kt index 94f0efe6..4dc7dcc1 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSAuthenticationSimulateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSAuthenticationSimulateParams.kt @@ -38,6 +38,12 @@ constructor( fun cardExpiryCheck(): CardExpiryCheck? = cardExpiryCheck + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ThreeDSAuthenticationSimulateBody { return ThreeDSAuthenticationSimulateBody( merchant, @@ -165,25 +171,6 @@ constructor( "ThreeDSAuthenticationSimulateBody{merchant=$merchant, pan=$pan, transaction=$transaction, cardExpiryCheck=$cardExpiryCheck, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ThreeDSAuthenticationSimulateParams && merchant == other.merchant && pan == other.pan && transaction == other.transaction && cardExpiryCheck == other.cardExpiryCheck && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(merchant, pan, transaction, cardExpiryCheck, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ThreeDSAuthenticationSimulateParams{merchant=$merchant, pan=$pan, transaction=$transaction, cardExpiryCheck=$cardExpiryCheck, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -205,13 +192,15 @@ constructor( internal fun from( threeDSAuthenticationSimulateParams: ThreeDSAuthenticationSimulateParams ) = apply { - this.merchant = threeDSAuthenticationSimulateParams.merchant - this.pan = threeDSAuthenticationSimulateParams.pan - this.transaction = threeDSAuthenticationSimulateParams.transaction - this.cardExpiryCheck = threeDSAuthenticationSimulateParams.cardExpiryCheck - additionalHeaders(threeDSAuthenticationSimulateParams.additionalHeaders) - additionalQueryParams(threeDSAuthenticationSimulateParams.additionalQueryParams) - additionalBodyProperties(threeDSAuthenticationSimulateParams.additionalBodyProperties) + merchant = threeDSAuthenticationSimulateParams.merchant + pan = threeDSAuthenticationSimulateParams.pan + transaction = threeDSAuthenticationSimulateParams.transaction + cardExpiryCheck = threeDSAuthenticationSimulateParams.cardExpiryCheck + additionalHeaders = threeDSAuthenticationSimulateParams.additionalHeaders.toBuilder() + additionalQueryParams = + threeDSAuthenticationSimulateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + threeDSAuthenticationSimulateParams.additionalBodyProperties.toMutableMap() } fun merchant(merchant: Merchant) = apply { this.merchant = merchant } @@ -631,4 +620,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ThreeDSAuthenticationSimulateParams && merchant == other.merchant && pan == other.pan && transaction == other.transaction && cardExpiryCheck == other.cardExpiryCheck && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(merchant, pan, transaction, cardExpiryCheck, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ThreeDSAuthenticationSimulateParams{merchant=$merchant, pan=$pan, transaction=$transaction, cardExpiryCheck=$cardExpiryCheck, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningChallengeResponseParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningChallengeResponseParams.kt index c01dae52..111c26a2 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningChallengeResponseParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningChallengeResponseParams.kt @@ -28,6 +28,12 @@ constructor( fun challengeResponse(): ChallengeResult = challengeResponse + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ThreeDSDecisioningChallengeResponseBody { return ThreeDSDecisioningChallengeResponseBody( token, @@ -140,25 +146,6 @@ constructor( "ThreeDSDecisioningChallengeResponseBody{token=$token, challengeResponse=$challengeResponse, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ThreeDSDecisioningChallengeResponseParams && token == other.token && challengeResponse == other.challengeResponse && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, challengeResponse, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ThreeDSDecisioningChallengeResponseParams{token=$token, challengeResponse=$challengeResponse, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -178,13 +165,14 @@ constructor( internal fun from( threeDSDecisioningChallengeResponseParams: ThreeDSDecisioningChallengeResponseParams ) = apply { - this.token = threeDSDecisioningChallengeResponseParams.token - this.challengeResponse = threeDSDecisioningChallengeResponseParams.challengeResponse - additionalHeaders(threeDSDecisioningChallengeResponseParams.additionalHeaders) - additionalQueryParams(threeDSDecisioningChallengeResponseParams.additionalQueryParams) - additionalBodyProperties( - threeDSDecisioningChallengeResponseParams.additionalBodyProperties - ) + token = threeDSDecisioningChallengeResponseParams.token + challengeResponse = threeDSDecisioningChallengeResponseParams.challengeResponse + additionalHeaders = + threeDSDecisioningChallengeResponseParams.additionalHeaders.toBuilder() + additionalQueryParams = + threeDSDecisioningChallengeResponseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + threeDSDecisioningChallengeResponseParams.additionalBodyProperties.toMutableMap() } /** @@ -330,4 +318,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ThreeDSDecisioningChallengeResponseParams && token == other.token && challengeResponse == other.challengeResponse && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, challengeResponse, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ThreeDSDecisioningChallengeResponseParams{token=$token, challengeResponse=$challengeResponse, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningRetrieveSecretParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningRetrieveSecretParams.kt index e62eb585..12c3e741 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningRetrieveSecretParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningRetrieveSecretParams.kt @@ -14,26 +14,13 @@ constructor( private val additionalQueryParams: QueryParams, ) { - internal fun getHeaders(): Headers = additionalHeaders - - internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Headers = additionalHeaders fun _additionalQueryParams(): QueryParams = additionalQueryParams - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ThreeDSDecisioningRetrieveSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ + internal fun getHeaders(): Headers = additionalHeaders - override fun toString() = - "ThreeDSDecisioningRetrieveSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" + internal fun getQueryParams(): QueryParams = additionalQueryParams fun toBuilder() = Builder().from(this) @@ -51,8 +38,9 @@ constructor( internal fun from( threeDSDecisioningRetrieveSecretParams: ThreeDSDecisioningRetrieveSecretParams ) = apply { - additionalHeaders(threeDSDecisioningRetrieveSecretParams.additionalHeaders) - additionalQueryParams(threeDSDecisioningRetrieveSecretParams.additionalQueryParams) + additionalHeaders = threeDSDecisioningRetrieveSecretParams.additionalHeaders.toBuilder() + additionalQueryParams = + threeDSDecisioningRetrieveSecretParams.additionalQueryParams.toBuilder() } fun additionalHeaders(additionalHeaders: Headers) = apply { @@ -159,4 +147,17 @@ constructor( additionalQueryParams.build() ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ThreeDSDecisioningRetrieveSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ThreeDSDecisioningRetrieveSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningRotateSecretParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningRotateSecretParams.kt index 82ec841c..151afe18 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningRotateSecretParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningRotateSecretParams.kt @@ -17,32 +17,19 @@ constructor( private val additionalBodyProperties: Map, ) { - internal fun getBody(): Map? { - return additionalBodyProperties.ifEmpty { null } - } - - internal fun getHeaders(): Headers = additionalHeaders - - internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Headers = additionalHeaders fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ThreeDSDecisioningRotateSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + internal fun getBody(): Map? { + return additionalBodyProperties.ifEmpty { null } } - override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + internal fun getHeaders(): Headers = additionalHeaders - override fun toString() = - "ThreeDSDecisioningRotateSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" + internal fun getQueryParams(): QueryParams = additionalQueryParams fun toBuilder() = Builder().from(this) @@ -61,9 +48,11 @@ constructor( internal fun from( threeDSDecisioningRotateSecretParams: ThreeDSDecisioningRotateSecretParams ) = apply { - additionalHeaders(threeDSDecisioningRotateSecretParams.additionalHeaders) - additionalQueryParams(threeDSDecisioningRotateSecretParams.additionalQueryParams) - additionalBodyProperties(threeDSDecisioningRotateSecretParams.additionalBodyProperties) + additionalHeaders = threeDSDecisioningRotateSecretParams.additionalHeaders.toBuilder() + additionalQueryParams = + threeDSDecisioningRotateSecretParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + threeDSDecisioningRotateSecretParams.additionalBodyProperties.toMutableMap() } fun additionalHeaders(additionalHeaders: Headers) = apply { @@ -193,4 +182,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ThreeDSDecisioningRotateSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ThreeDSDecisioningRotateSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningSimulateChallengeParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningSimulateChallengeParams.kt index 7a9f59a4..8d26b2f6 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningSimulateChallengeParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningSimulateChallengeParams.kt @@ -25,6 +25,12 @@ constructor( fun token(): String? = token + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ThreeDSDecisioningSimulateChallengeBody { return ThreeDSDecisioningSimulateChallengeBody(token, additionalBodyProperties) } @@ -112,25 +118,6 @@ constructor( "ThreeDSDecisioningSimulateChallengeBody{token=$token, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ThreeDSDecisioningSimulateChallengeParams && token == other.token && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ThreeDSDecisioningSimulateChallengeParams{token=$token, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -149,12 +136,13 @@ constructor( internal fun from( threeDSDecisioningSimulateChallengeParams: ThreeDSDecisioningSimulateChallengeParams ) = apply { - this.token = threeDSDecisioningSimulateChallengeParams.token - additionalHeaders(threeDSDecisioningSimulateChallengeParams.additionalHeaders) - additionalQueryParams(threeDSDecisioningSimulateChallengeParams.additionalQueryParams) - additionalBodyProperties( - threeDSDecisioningSimulateChallengeParams.additionalBodyProperties - ) + token = threeDSDecisioningSimulateChallengeParams.token + additionalHeaders = + threeDSDecisioningSimulateChallengeParams.additionalHeaders.toBuilder() + additionalQueryParams = + threeDSDecisioningSimulateChallengeParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + threeDSDecisioningSimulateChallengeParams.additionalBodyProperties.toMutableMap() } /** @@ -291,4 +279,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ThreeDSDecisioningSimulateChallengeParams && token == other.token && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ThreeDSDecisioningSimulateChallengeParams{token=$token, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningSimulateChallengeResponseParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningSimulateChallengeResponseParams.kt index f572624b..81ea6167 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningSimulateChallengeResponseParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/ThreeDSDecisioningSimulateChallengeResponseParams.kt @@ -28,6 +28,12 @@ constructor( fun challengeResponse(): ChallengeResult = challengeResponse + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): ThreeDSDecisioningSimulateChallengeResponseBody { return ThreeDSDecisioningSimulateChallengeResponseBody( token, @@ -144,25 +150,6 @@ constructor( "ThreeDSDecisioningSimulateChallengeResponseBody{token=$token, challengeResponse=$challengeResponse, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is ThreeDSDecisioningSimulateChallengeResponseParams && token == other.token && challengeResponse == other.challengeResponse && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, challengeResponse, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "ThreeDSDecisioningSimulateChallengeResponseParams{token=$token, challengeResponse=$challengeResponse, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -183,16 +170,15 @@ constructor( threeDSDecisioningSimulateChallengeResponseParams: ThreeDSDecisioningSimulateChallengeResponseParams ) = apply { - this.token = threeDSDecisioningSimulateChallengeResponseParams.token - this.challengeResponse = - threeDSDecisioningSimulateChallengeResponseParams.challengeResponse - additionalHeaders(threeDSDecisioningSimulateChallengeResponseParams.additionalHeaders) - additionalQueryParams( - threeDSDecisioningSimulateChallengeResponseParams.additionalQueryParams - ) - additionalBodyProperties( + token = threeDSDecisioningSimulateChallengeResponseParams.token + challengeResponse = threeDSDecisioningSimulateChallengeResponseParams.challengeResponse + additionalHeaders = + threeDSDecisioningSimulateChallengeResponseParams.additionalHeaders.toBuilder() + additionalQueryParams = + threeDSDecisioningSimulateChallengeResponseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = threeDSDecisioningSimulateChallengeResponseParams.additionalBodyProperties - ) + .toMutableMap() } /** @@ -338,4 +324,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ThreeDSDecisioningSimulateChallengeResponseParams && token == other.token && challengeResponse == other.challengeResponse && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, challengeResponse, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ThreeDSDecisioningSimulateChallengeResponseParams{token=$token, challengeResponse=$challengeResponse, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationActivateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationActivateParams.kt index 9fb183eb..dc649381 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationActivateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationActivateParams.kt @@ -20,6 +20,12 @@ constructor( fun tokenizationToken(): String = tokenizationToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationActivateParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TokenizationActivateParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -70,10 +57,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationActivateParams: TokenizationActivateParams) = apply { - this.tokenizationToken = tokenizationActivateParams.tokenizationToken - additionalHeaders(tokenizationActivateParams.additionalHeaders) - additionalQueryParams(tokenizationActivateParams.additionalQueryParams) - additionalBodyProperties(tokenizationActivateParams.additionalBodyProperties) + tokenizationToken = tokenizationActivateParams.tokenizationToken + additionalHeaders = tokenizationActivateParams.additionalHeaders.toBuilder() + additionalQueryParams = tokenizationActivateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + tokenizationActivateParams.additionalBodyProperties.toMutableMap() } fun tokenizationToken(tokenizationToken: String) = apply { @@ -210,4 +198,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationActivateParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TokenizationActivateParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDeactivateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDeactivateParams.kt index 42b624a7..71b18120 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDeactivateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDeactivateParams.kt @@ -20,6 +20,12 @@ constructor( fun tokenizationToken(): String = tokenizationToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationDeactivateParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TokenizationDeactivateParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -70,10 +57,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationDeactivateParams: TokenizationDeactivateParams) = apply { - this.tokenizationToken = tokenizationDeactivateParams.tokenizationToken - additionalHeaders(tokenizationDeactivateParams.additionalHeaders) - additionalQueryParams(tokenizationDeactivateParams.additionalQueryParams) - additionalBodyProperties(tokenizationDeactivateParams.additionalBodyProperties) + tokenizationToken = tokenizationDeactivateParams.tokenizationToken + additionalHeaders = tokenizationDeactivateParams.additionalHeaders.toBuilder() + additionalQueryParams = tokenizationDeactivateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + tokenizationDeactivateParams.additionalBodyProperties.toMutableMap() } fun tokenizationToken(tokenizationToken: String) = apply { @@ -210,4 +198,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationDeactivateParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TokenizationDeactivateParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDecisioningRetrieveSecretParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDecisioningRetrieveSecretParams.kt index 542f70bf..1560d1bc 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDecisioningRetrieveSecretParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDecisioningRetrieveSecretParams.kt @@ -14,26 +14,13 @@ constructor( private val additionalQueryParams: QueryParams, ) { - internal fun getHeaders(): Headers = additionalHeaders - - internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Headers = additionalHeaders fun _additionalQueryParams(): QueryParams = additionalQueryParams - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationDecisioningRetrieveSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ + internal fun getHeaders(): Headers = additionalHeaders - override fun toString() = - "TokenizationDecisioningRetrieveSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" + internal fun getQueryParams(): QueryParams = additionalQueryParams fun toBuilder() = Builder().from(this) @@ -51,8 +38,10 @@ constructor( internal fun from( tokenizationDecisioningRetrieveSecretParams: TokenizationDecisioningRetrieveSecretParams ) = apply { - additionalHeaders(tokenizationDecisioningRetrieveSecretParams.additionalHeaders) - additionalQueryParams(tokenizationDecisioningRetrieveSecretParams.additionalQueryParams) + additionalHeaders = + tokenizationDecisioningRetrieveSecretParams.additionalHeaders.toBuilder() + additionalQueryParams = + tokenizationDecisioningRetrieveSecretParams.additionalQueryParams.toBuilder() } fun additionalHeaders(additionalHeaders: Headers) = apply { @@ -159,4 +148,17 @@ constructor( additionalQueryParams.build() ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationDecisioningRetrieveSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "TokenizationDecisioningRetrieveSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDecisioningRotateSecretParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDecisioningRotateSecretParams.kt index 2f9d62ad..da27c707 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDecisioningRotateSecretParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationDecisioningRotateSecretParams.kt @@ -17,32 +17,19 @@ constructor( private val additionalBodyProperties: Map, ) { - internal fun getBody(): Map? { - return additionalBodyProperties.ifEmpty { null } - } - - internal fun getHeaders(): Headers = additionalHeaders - - internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Headers = additionalHeaders fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationDecisioningRotateSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + internal fun getBody(): Map? { + return additionalBodyProperties.ifEmpty { null } } - override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + internal fun getHeaders(): Headers = additionalHeaders - override fun toString() = - "TokenizationDecisioningRotateSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" + internal fun getQueryParams(): QueryParams = additionalQueryParams fun toBuilder() = Builder().from(this) @@ -61,11 +48,12 @@ constructor( internal fun from( tokenizationDecisioningRotateSecretParams: TokenizationDecisioningRotateSecretParams ) = apply { - additionalHeaders(tokenizationDecisioningRotateSecretParams.additionalHeaders) - additionalQueryParams(tokenizationDecisioningRotateSecretParams.additionalQueryParams) - additionalBodyProperties( - tokenizationDecisioningRotateSecretParams.additionalBodyProperties - ) + additionalHeaders = + tokenizationDecisioningRotateSecretParams.additionalHeaders.toBuilder() + additionalQueryParams = + tokenizationDecisioningRotateSecretParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + tokenizationDecisioningRotateSecretParams.additionalBodyProperties.toMutableMap() } fun additionalHeaders(additionalHeaders: Headers) = apply { @@ -195,4 +183,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationDecisioningRotateSecretParams && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TokenizationDecisioningRotateSecretParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationListParams.kt index 232b3e78..97189880 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationListParams.kt @@ -44,6 +44,10 @@ constructor( fun tokenizationChannel(): TokenizationChannel? = tokenizationChannel + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -62,23 +66,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationListParams && accountToken == other.accountToken && begin == other.begin && cardToken == other.cardToken && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && tokenizationChannel == other.tokenizationChannel && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, cardToken, end, endingBefore, pageSize, startingAfter, tokenizationChannel, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "TokenizationListParams{accountToken=$accountToken, begin=$begin, cardToken=$cardToken, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, tokenizationChannel=$tokenizationChannel, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -101,16 +88,16 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(tokenizationListParams: TokenizationListParams) = apply { - this.accountToken = tokenizationListParams.accountToken - this.begin = tokenizationListParams.begin - this.cardToken = tokenizationListParams.cardToken - this.end = tokenizationListParams.end - this.endingBefore = tokenizationListParams.endingBefore - this.pageSize = tokenizationListParams.pageSize - this.startingAfter = tokenizationListParams.startingAfter - this.tokenizationChannel = tokenizationListParams.tokenizationChannel - additionalHeaders(tokenizationListParams.additionalHeaders) - additionalQueryParams(tokenizationListParams.additionalQueryParams) + accountToken = tokenizationListParams.accountToken + begin = tokenizationListParams.begin + cardToken = tokenizationListParams.cardToken + end = tokenizationListParams.end + endingBefore = tokenizationListParams.endingBefore + pageSize = tokenizationListParams.pageSize + startingAfter = tokenizationListParams.startingAfter + tokenizationChannel = tokenizationListParams.tokenizationChannel + additionalHeaders = tokenizationListParams.additionalHeaders.toBuilder() + additionalQueryParams = tokenizationListParams.additionalQueryParams.toBuilder() } /** Filters for tokenizations associated with a specific account. */ @@ -323,4 +310,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationListParams && accountToken == other.accountToken && begin == other.begin && cardToken == other.cardToken && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && startingAfter == other.startingAfter && tokenizationChannel == other.tokenizationChannel && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, cardToken, end, endingBefore, pageSize, startingAfter, tokenizationChannel, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "TokenizationListParams{accountToken=$accountToken, begin=$begin, cardToken=$cardToken, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, startingAfter=$startingAfter, tokenizationChannel=$tokenizationChannel, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationPauseParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationPauseParams.kt index 5f3c9ec6..ee20d7e5 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationPauseParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationPauseParams.kt @@ -20,6 +20,12 @@ constructor( fun tokenizationToken(): String = tokenizationToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationPauseParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TokenizationPauseParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -70,10 +57,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationPauseParams: TokenizationPauseParams) = apply { - this.tokenizationToken = tokenizationPauseParams.tokenizationToken - additionalHeaders(tokenizationPauseParams.additionalHeaders) - additionalQueryParams(tokenizationPauseParams.additionalQueryParams) - additionalBodyProperties(tokenizationPauseParams.additionalBodyProperties) + tokenizationToken = tokenizationPauseParams.tokenizationToken + additionalHeaders = tokenizationPauseParams.additionalHeaders.toBuilder() + additionalQueryParams = tokenizationPauseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + tokenizationPauseParams.additionalBodyProperties.toMutableMap() } fun tokenizationToken(tokenizationToken: String) = apply { @@ -210,4 +198,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationPauseParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TokenizationPauseParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationResendActivationCodeParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationResendActivationCodeParams.kt index f936f028..74f6074e 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationResendActivationCodeParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationResendActivationCodeParams.kt @@ -32,6 +32,12 @@ constructor( fun activationMethodType(): ActivationMethodType? = activationMethodType + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TokenizationResendActivationCodeBody { return TokenizationResendActivationCodeBody(activationMethodType, additionalBodyProperties) } @@ -136,25 +142,6 @@ constructor( "TokenizationResendActivationCodeBody{activationMethodType=$activationMethodType, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationResendActivationCodeParams && tokenizationToken == other.tokenizationToken && activationMethodType == other.activationMethodType && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, activationMethodType, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TokenizationResendActivationCodeParams{tokenizationToken=$tokenizationToken, activationMethodType=$activationMethodType, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -174,13 +161,13 @@ constructor( internal fun from( tokenizationResendActivationCodeParams: TokenizationResendActivationCodeParams ) = apply { - this.tokenizationToken = tokenizationResendActivationCodeParams.tokenizationToken - this.activationMethodType = tokenizationResendActivationCodeParams.activationMethodType - additionalHeaders(tokenizationResendActivationCodeParams.additionalHeaders) - additionalQueryParams(tokenizationResendActivationCodeParams.additionalQueryParams) - additionalBodyProperties( - tokenizationResendActivationCodeParams.additionalBodyProperties - ) + tokenizationToken = tokenizationResendActivationCodeParams.tokenizationToken + activationMethodType = tokenizationResendActivationCodeParams.activationMethodType + additionalHeaders = tokenizationResendActivationCodeParams.additionalHeaders.toBuilder() + additionalQueryParams = + tokenizationResendActivationCodeParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + tokenizationResendActivationCodeParams.additionalBodyProperties.toMutableMap() } fun tokenizationToken(tokenizationToken: String) = apply { @@ -386,4 +373,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationResendActivationCodeParams && tokenizationToken == other.tokenizationToken && activationMethodType == other.activationMethodType && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, activationMethodType, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TokenizationResendActivationCodeParams{tokenizationToken=$tokenizationToken, activationMethodType=$activationMethodType, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationRetrieveParams.kt index 27501805..99928dea 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun tokenizationToken(): String = tokenizationToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationRetrieveParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "TokenizationRetrieveParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(tokenizationRetrieveParams: TokenizationRetrieveParams) = apply { - this.tokenizationToken = tokenizationRetrieveParams.tokenizationToken - additionalHeaders(tokenizationRetrieveParams.additionalHeaders) - additionalQueryParams(tokenizationRetrieveParams.additionalQueryParams) + tokenizationToken = tokenizationRetrieveParams.tokenizationToken + additionalHeaders = tokenizationRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = tokenizationRetrieveParams.additionalQueryParams.toBuilder() } fun tokenizationToken(tokenizationToken: String) = apply { @@ -176,4 +163,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationRetrieveParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "TokenizationRetrieveParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationSimulateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationSimulateParams.kt index 6a7dcc4e..f1791d51 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationSimulateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationSimulateParams.kt @@ -50,6 +50,12 @@ constructor( fun walletRecommendedDecision(): WalletRecommendedDecision? = walletRecommendedDecision + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TokenizationSimulateBody { return TokenizationSimulateBody( cvv, @@ -246,25 +252,6 @@ constructor( "TokenizationSimulateBody{cvv=$cvv, expirationDate=$expirationDate, pan=$pan, tokenizationSource=$tokenizationSource, accountScore=$accountScore, deviceScore=$deviceScore, entity=$entity, walletRecommendedDecision=$walletRecommendedDecision, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationSimulateParams && cvv == other.cvv && expirationDate == other.expirationDate && pan == other.pan && tokenizationSource == other.tokenizationSource && accountScore == other.accountScore && deviceScore == other.deviceScore && entity == other.entity && walletRecommendedDecision == other.walletRecommendedDecision && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(cvv, expirationDate, pan, tokenizationSource, accountScore, deviceScore, entity, walletRecommendedDecision, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TokenizationSimulateParams{cvv=$cvv, expirationDate=$expirationDate, pan=$pan, tokenizationSource=$tokenizationSource, accountScore=$accountScore, deviceScore=$deviceScore, entity=$entity, walletRecommendedDecision=$walletRecommendedDecision, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -288,17 +275,18 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationSimulateParams: TokenizationSimulateParams) = apply { - this.cvv = tokenizationSimulateParams.cvv - this.expirationDate = tokenizationSimulateParams.expirationDate - this.pan = tokenizationSimulateParams.pan - this.tokenizationSource = tokenizationSimulateParams.tokenizationSource - this.accountScore = tokenizationSimulateParams.accountScore - this.deviceScore = tokenizationSimulateParams.deviceScore - this.entity = tokenizationSimulateParams.entity - this.walletRecommendedDecision = tokenizationSimulateParams.walletRecommendedDecision - additionalHeaders(tokenizationSimulateParams.additionalHeaders) - additionalQueryParams(tokenizationSimulateParams.additionalQueryParams) - additionalBodyProperties(tokenizationSimulateParams.additionalBodyProperties) + cvv = tokenizationSimulateParams.cvv + expirationDate = tokenizationSimulateParams.expirationDate + pan = tokenizationSimulateParams.pan + tokenizationSource = tokenizationSimulateParams.tokenizationSource + accountScore = tokenizationSimulateParams.accountScore + deviceScore = tokenizationSimulateParams.deviceScore + entity = tokenizationSimulateParams.entity + walletRecommendedDecision = tokenizationSimulateParams.walletRecommendedDecision + additionalHeaders = tokenizationSimulateParams.additionalHeaders.toBuilder() + additionalQueryParams = tokenizationSimulateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + tokenizationSimulateParams.additionalBodyProperties.toMutableMap() } /** The three digit cvv for the card. */ @@ -610,4 +598,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationSimulateParams && cvv == other.cvv && expirationDate == other.expirationDate && pan == other.pan && tokenizationSource == other.tokenizationSource && accountScore == other.accountScore && deviceScore == other.deviceScore && entity == other.entity && walletRecommendedDecision == other.walletRecommendedDecision && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(cvv, expirationDate, pan, tokenizationSource, accountScore, deviceScore, entity, walletRecommendedDecision, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TokenizationSimulateParams{cvv=$cvv, expirationDate=$expirationDate, pan=$pan, tokenizationSource=$tokenizationSource, accountScore=$accountScore, deviceScore=$deviceScore, entity=$entity, walletRecommendedDecision=$walletRecommendedDecision, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationUnpauseParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationUnpauseParams.kt index c23e2950..e32c048d 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationUnpauseParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationUnpauseParams.kt @@ -20,6 +20,12 @@ constructor( fun tokenizationToken(): String = tokenizationToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): Map? { return additionalBodyProperties.ifEmpty { null } } @@ -35,25 +41,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationUnpauseParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TokenizationUnpauseParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -70,10 +57,11 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationUnpauseParams: TokenizationUnpauseParams) = apply { - this.tokenizationToken = tokenizationUnpauseParams.tokenizationToken - additionalHeaders(tokenizationUnpauseParams.additionalHeaders) - additionalQueryParams(tokenizationUnpauseParams.additionalQueryParams) - additionalBodyProperties(tokenizationUnpauseParams.additionalBodyProperties) + tokenizationToken = tokenizationUnpauseParams.tokenizationToken + additionalHeaders = tokenizationUnpauseParams.additionalHeaders.toBuilder() + additionalQueryParams = tokenizationUnpauseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + tokenizationUnpauseParams.additionalBodyProperties.toMutableMap() } fun tokenizationToken(tokenizationToken: String) = apply { @@ -210,4 +198,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationUnpauseParams && tokenizationToken == other.tokenizationToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TokenizationUnpauseParams{tokenizationToken=$tokenizationToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationUpdateDigitalCardArtParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationUpdateDigitalCardArtParams.kt index 276119ff..aae4a0d3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationUpdateDigitalCardArtParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TokenizationUpdateDigitalCardArtParams.kt @@ -28,6 +28,12 @@ constructor( fun digitalCardArtToken(): String? = digitalCardArtToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TokenizationUpdateDigitalCardArtBody { return TokenizationUpdateDigitalCardArtBody(digitalCardArtToken, additionalBodyProperties) } @@ -133,25 +139,6 @@ constructor( "TokenizationUpdateDigitalCardArtBody{digitalCardArtToken=$digitalCardArtToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TokenizationUpdateDigitalCardArtParams && tokenizationToken == other.tokenizationToken && digitalCardArtToken == other.digitalCardArtToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, digitalCardArtToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TokenizationUpdateDigitalCardArtParams{tokenizationToken=$tokenizationToken, digitalCardArtToken=$digitalCardArtToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -171,13 +158,13 @@ constructor( internal fun from( tokenizationUpdateDigitalCardArtParams: TokenizationUpdateDigitalCardArtParams ) = apply { - this.tokenizationToken = tokenizationUpdateDigitalCardArtParams.tokenizationToken - this.digitalCardArtToken = tokenizationUpdateDigitalCardArtParams.digitalCardArtToken - additionalHeaders(tokenizationUpdateDigitalCardArtParams.additionalHeaders) - additionalQueryParams(tokenizationUpdateDigitalCardArtParams.additionalQueryParams) - additionalBodyProperties( - tokenizationUpdateDigitalCardArtParams.additionalBodyProperties - ) + tokenizationToken = tokenizationUpdateDigitalCardArtParams.tokenizationToken + digitalCardArtToken = tokenizationUpdateDigitalCardArtParams.digitalCardArtToken + additionalHeaders = tokenizationUpdateDigitalCardArtParams.additionalHeaders.toBuilder() + additionalQueryParams = + tokenizationUpdateDigitalCardArtParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + tokenizationUpdateDigitalCardArtParams.additionalBodyProperties.toMutableMap() } fun tokenizationToken(tokenizationToken: String) = apply { @@ -325,4 +312,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TokenizationUpdateDigitalCardArtParams && tokenizationToken == other.tokenizationToken && digitalCardArtToken == other.digitalCardArtToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(tokenizationToken, digitalCardArtToken, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TokenizationUpdateDigitalCardArtParams{tokenizationToken=$tokenizationToken, digitalCardArtToken=$digitalCardArtToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionEnhancedCommercialDataRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionEnhancedCommercialDataRetrieveParams.kt index cc379046..46e06900 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionEnhancedCommercialDataRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionEnhancedCommercialDataRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun transactionToken(): String = transactionToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionEnhancedCommercialDataRetrieveParams && transactionToken == other.transactionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(transactionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "TransactionEnhancedCommercialDataRetrieveParams{transactionToken=$transactionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -63,11 +50,11 @@ constructor( transactionEnhancedCommercialDataRetrieveParams: TransactionEnhancedCommercialDataRetrieveParams ) = apply { - this.transactionToken = transactionEnhancedCommercialDataRetrieveParams.transactionToken - additionalHeaders(transactionEnhancedCommercialDataRetrieveParams.additionalHeaders) - additionalQueryParams( - transactionEnhancedCommercialDataRetrieveParams.additionalQueryParams - ) + transactionToken = transactionEnhancedCommercialDataRetrieveParams.transactionToken + additionalHeaders = + transactionEnhancedCommercialDataRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + transactionEnhancedCommercialDataRetrieveParams.additionalQueryParams.toBuilder() } fun transactionToken(transactionToken: String) = apply { @@ -179,4 +166,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionEnhancedCommercialDataRetrieveParams && transactionToken == other.transactionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(transactionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "TransactionEnhancedCommercialDataRetrieveParams{transactionToken=$transactionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionEventEnhancedCommercialDataRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionEventEnhancedCommercialDataRetrieveParams.kt index 46fbee19..565ac330 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionEventEnhancedCommercialDataRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionEventEnhancedCommercialDataRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun eventToken(): String = eventToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionEventEnhancedCommercialDataRetrieveParams && eventToken == other.eventToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "TransactionEventEnhancedCommercialDataRetrieveParams{eventToken=$eventToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -63,13 +50,12 @@ constructor( transactionEventEnhancedCommercialDataRetrieveParams: TransactionEventEnhancedCommercialDataRetrieveParams ) = apply { - this.eventToken = transactionEventEnhancedCommercialDataRetrieveParams.eventToken - additionalHeaders( - transactionEventEnhancedCommercialDataRetrieveParams.additionalHeaders - ) - additionalQueryParams( + eventToken = transactionEventEnhancedCommercialDataRetrieveParams.eventToken + additionalHeaders = + transactionEventEnhancedCommercialDataRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = transactionEventEnhancedCommercialDataRetrieveParams.additionalQueryParams - ) + .toBuilder() } fun eventToken(eventToken: String) = apply { this.eventToken = eventToken } @@ -179,4 +165,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionEventEnhancedCommercialDataRetrieveParams && eventToken == other.eventToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(eventToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "TransactionEventEnhancedCommercialDataRetrieveParams{eventToken=$eventToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionListParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionListParams.kt index a05fdea9..cd825d21 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionListParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionListParams.kt @@ -45,6 +45,10 @@ constructor( fun startingAfter(): String? = startingAfter + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams { @@ -65,23 +69,6 @@ constructor( return queryParams.build() } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionListParams && accountToken == other.accountToken && begin == other.begin && cardToken == other.cardToken && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && result == other.result && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, cardToken, end, endingBefore, pageSize, result, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "TransactionListParams{accountToken=$accountToken, begin=$begin, cardToken=$cardToken, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, result=$result, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -104,16 +91,16 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(transactionListParams: TransactionListParams) = apply { - this.accountToken = transactionListParams.accountToken - this.begin = transactionListParams.begin - this.cardToken = transactionListParams.cardToken - this.end = transactionListParams.end - this.endingBefore = transactionListParams.endingBefore - this.pageSize = transactionListParams.pageSize - this.result = transactionListParams.result - this.startingAfter = transactionListParams.startingAfter - additionalHeaders(transactionListParams.additionalHeaders) - additionalQueryParams(transactionListParams.additionalQueryParams) + accountToken = transactionListParams.accountToken + begin = transactionListParams.begin + cardToken = transactionListParams.cardToken + end = transactionListParams.end + endingBefore = transactionListParams.endingBefore + pageSize = transactionListParams.pageSize + result = transactionListParams.result + startingAfter = transactionListParams.startingAfter + additionalHeaders = transactionListParams.additionalHeaders.toBuilder() + additionalQueryParams = transactionListParams.additionalQueryParams.toBuilder() } /** Filters for transactions associated with a specific account. */ @@ -324,4 +311,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionListParams && accountToken == other.accountToken && begin == other.begin && cardToken == other.cardToken && end == other.end && endingBefore == other.endingBefore && pageSize == other.pageSize && result == other.result && startingAfter == other.startingAfter && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountToken, begin, cardToken, end, endingBefore, pageSize, result, startingAfter, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "TransactionListParams{accountToken=$accountToken, begin=$begin, cardToken=$cardToken, end=$end, endingBefore=$endingBefore, pageSize=$pageSize, result=$result, startingAfter=$startingAfter, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionRetrieveParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionRetrieveParams.kt index 8c7ff7ac..7d47135a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionRetrieveParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionRetrieveParams.kt @@ -17,6 +17,10 @@ constructor( fun transactionToken(): String = transactionToken + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + internal fun getHeaders(): Headers = additionalHeaders internal fun getQueryParams(): QueryParams = additionalQueryParams @@ -28,23 +32,6 @@ constructor( } } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionRetrieveParams && transactionToken == other.transactionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(transactionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ - - override fun toString() = - "TransactionRetrieveParams{transactionToken=$transactionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" - fun toBuilder() = Builder().from(this) companion object { @@ -60,9 +47,9 @@ constructor( private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(transactionRetrieveParams: TransactionRetrieveParams) = apply { - this.transactionToken = transactionRetrieveParams.transactionToken - additionalHeaders(transactionRetrieveParams.additionalHeaders) - additionalQueryParams(transactionRetrieveParams.additionalQueryParams) + transactionToken = transactionRetrieveParams.transactionToken + additionalHeaders = transactionRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = transactionRetrieveParams.additionalQueryParams.toBuilder() } fun transactionToken(transactionToken: String) = apply { @@ -174,4 +161,17 @@ constructor( additionalQueryParams.build(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionRetrieveParams && transactionToken == other.transactionToken && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(transactionToken, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "TransactionRetrieveParams{transactionToken=$transactionToken, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateAuthorizationAdviceParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateAuthorizationAdviceParams.kt index d8214b11..9bbb2746 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateAuthorizationAdviceParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateAuthorizationAdviceParams.kt @@ -28,6 +28,12 @@ constructor( fun amount(): Long = amount + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TransactionSimulateAuthorizationAdviceBody { return TransactionSimulateAuthorizationAdviceBody( token, @@ -135,25 +141,6 @@ constructor( "TransactionSimulateAuthorizationAdviceBody{token=$token, amount=$amount, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionSimulateAuthorizationAdviceParams && token == other.token && amount == other.amount && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, amount, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TransactionSimulateAuthorizationAdviceParams{token=$token, amount=$amount, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -174,15 +161,14 @@ constructor( transactionSimulateAuthorizationAdviceParams: TransactionSimulateAuthorizationAdviceParams ) = apply { - this.token = transactionSimulateAuthorizationAdviceParams.token - this.amount = transactionSimulateAuthorizationAdviceParams.amount - additionalHeaders(transactionSimulateAuthorizationAdviceParams.additionalHeaders) - additionalQueryParams( - transactionSimulateAuthorizationAdviceParams.additionalQueryParams - ) - additionalBodyProperties( - transactionSimulateAuthorizationAdviceParams.additionalBodyProperties - ) + token = transactionSimulateAuthorizationAdviceParams.token + amount = transactionSimulateAuthorizationAdviceParams.amount + additionalHeaders = + transactionSimulateAuthorizationAdviceParams.additionalHeaders.toBuilder() + additionalQueryParams = + transactionSimulateAuthorizationAdviceParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + transactionSimulateAuthorizationAdviceParams.additionalBodyProperties.toMutableMap() } /** The transaction token returned from the /v1/simulate/authorize response. */ @@ -323,4 +309,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionSimulateAuthorizationAdviceParams && token == other.token && amount == other.amount && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, amount, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TransactionSimulateAuthorizationAdviceParams{token=$token, amount=$amount, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateAuthorizationParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateAuthorizationParams.kt index c52b1955..14bce87a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateAuthorizationParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateAuthorizationParams.kt @@ -53,6 +53,12 @@ constructor( fun status(): Status? = status + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TransactionSimulateAuthorizationBody { return TransactionSimulateAuthorizationBody( amount, @@ -311,25 +317,6 @@ constructor( "TransactionSimulateAuthorizationBody{amount=$amount, descriptor=$descriptor, pan=$pan, mcc=$mcc, merchantAcceptorId=$merchantAcceptorId, merchantAmount=$merchantAmount, merchantCurrency=$merchantCurrency, partialApprovalCapable=$partialApprovalCapable, status=$status, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionSimulateAuthorizationParams && amount == other.amount && descriptor == other.descriptor && pan == other.pan && mcc == other.mcc && merchantAcceptorId == other.merchantAcceptorId && merchantAmount == other.merchantAmount && merchantCurrency == other.merchantCurrency && partialApprovalCapable == other.partialApprovalCapable && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, descriptor, pan, mcc, merchantAcceptorId, merchantAmount, merchantCurrency, partialApprovalCapable, status, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TransactionSimulateAuthorizationParams{amount=$amount, descriptor=$descriptor, pan=$pan, mcc=$mcc, merchantAcceptorId=$merchantAcceptorId, merchantAmount=$merchantAmount, merchantCurrency=$merchantCurrency, partialApprovalCapable=$partialApprovalCapable, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -356,21 +343,20 @@ constructor( internal fun from( transactionSimulateAuthorizationParams: TransactionSimulateAuthorizationParams ) = apply { - this.amount = transactionSimulateAuthorizationParams.amount - this.descriptor = transactionSimulateAuthorizationParams.descriptor - this.pan = transactionSimulateAuthorizationParams.pan - this.mcc = transactionSimulateAuthorizationParams.mcc - this.merchantAcceptorId = transactionSimulateAuthorizationParams.merchantAcceptorId - this.merchantAmount = transactionSimulateAuthorizationParams.merchantAmount - this.merchantCurrency = transactionSimulateAuthorizationParams.merchantCurrency - this.partialApprovalCapable = - transactionSimulateAuthorizationParams.partialApprovalCapable - this.status = transactionSimulateAuthorizationParams.status - additionalHeaders(transactionSimulateAuthorizationParams.additionalHeaders) - additionalQueryParams(transactionSimulateAuthorizationParams.additionalQueryParams) - additionalBodyProperties( - transactionSimulateAuthorizationParams.additionalBodyProperties - ) + amount = transactionSimulateAuthorizationParams.amount + descriptor = transactionSimulateAuthorizationParams.descriptor + pan = transactionSimulateAuthorizationParams.pan + mcc = transactionSimulateAuthorizationParams.mcc + merchantAcceptorId = transactionSimulateAuthorizationParams.merchantAcceptorId + merchantAmount = transactionSimulateAuthorizationParams.merchantAmount + merchantCurrency = transactionSimulateAuthorizationParams.merchantCurrency + partialApprovalCapable = transactionSimulateAuthorizationParams.partialApprovalCapable + status = transactionSimulateAuthorizationParams.status + additionalHeaders = transactionSimulateAuthorizationParams.additionalHeaders.toBuilder() + additionalQueryParams = + transactionSimulateAuthorizationParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + transactionSimulateAuthorizationParams.additionalBodyProperties.toMutableMap() } /** @@ -651,4 +637,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionSimulateAuthorizationParams && amount == other.amount && descriptor == other.descriptor && pan == other.pan && mcc == other.mcc && merchantAcceptorId == other.merchantAcceptorId && merchantAmount == other.merchantAmount && merchantCurrency == other.merchantCurrency && partialApprovalCapable == other.partialApprovalCapable && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, descriptor, pan, mcc, merchantAcceptorId, merchantAmount, merchantCurrency, partialApprovalCapable, status, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TransactionSimulateAuthorizationParams{amount=$amount, descriptor=$descriptor, pan=$pan, mcc=$mcc, merchantAcceptorId=$merchantAcceptorId, merchantAmount=$merchantAmount, merchantCurrency=$merchantCurrency, partialApprovalCapable=$partialApprovalCapable, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateClearingParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateClearingParams.kt index fe4638d0..9b182ded 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateClearingParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateClearingParams.kt @@ -28,6 +28,12 @@ constructor( fun amount(): Long? = amount + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TransactionSimulateClearingBody { return TransactionSimulateClearingBody( token, @@ -139,25 +145,6 @@ constructor( "TransactionSimulateClearingBody{token=$token, amount=$amount, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionSimulateClearingParams && token == other.token && amount == other.amount && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, amount, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TransactionSimulateClearingParams{token=$token, amount=$amount, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -176,11 +163,13 @@ constructor( internal fun from(transactionSimulateClearingParams: TransactionSimulateClearingParams) = apply { - this.token = transactionSimulateClearingParams.token - this.amount = transactionSimulateClearingParams.amount - additionalHeaders(transactionSimulateClearingParams.additionalHeaders) - additionalQueryParams(transactionSimulateClearingParams.additionalQueryParams) - additionalBodyProperties(transactionSimulateClearingParams.additionalBodyProperties) + token = transactionSimulateClearingParams.token + amount = transactionSimulateClearingParams.amount + additionalHeaders = transactionSimulateClearingParams.additionalHeaders.toBuilder() + additionalQueryParams = + transactionSimulateClearingParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + transactionSimulateClearingParams.additionalBodyProperties.toMutableMap() } /** The transaction token returned from the /v1/simulate/authorize response. */ @@ -325,4 +314,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionSimulateClearingParams && token == other.token && amount == other.amount && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, amount, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TransactionSimulateClearingParams{token=$token, amount=$amount, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateCreditAuthorizationParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateCreditAuthorizationParams.kt index 2d920e7b..89c5045a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateCreditAuthorizationParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateCreditAuthorizationParams.kt @@ -37,6 +37,12 @@ constructor( fun merchantAcceptorId(): String? = merchantAcceptorId + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TransactionSimulateCreditAuthorizationBody { return TransactionSimulateCreditAuthorizationBody( amount, @@ -192,25 +198,6 @@ constructor( "TransactionSimulateCreditAuthorizationBody{amount=$amount, descriptor=$descriptor, pan=$pan, mcc=$mcc, merchantAcceptorId=$merchantAcceptorId, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionSimulateCreditAuthorizationParams && amount == other.amount && descriptor == other.descriptor && pan == other.pan && mcc == other.mcc && merchantAcceptorId == other.merchantAcceptorId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, descriptor, pan, mcc, merchantAcceptorId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TransactionSimulateCreditAuthorizationParams{amount=$amount, descriptor=$descriptor, pan=$pan, mcc=$mcc, merchantAcceptorId=$merchantAcceptorId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -234,19 +221,17 @@ constructor( transactionSimulateCreditAuthorizationParams: TransactionSimulateCreditAuthorizationParams ) = apply { - this.amount = transactionSimulateCreditAuthorizationParams.amount - this.descriptor = transactionSimulateCreditAuthorizationParams.descriptor - this.pan = transactionSimulateCreditAuthorizationParams.pan - this.mcc = transactionSimulateCreditAuthorizationParams.mcc - this.merchantAcceptorId = - transactionSimulateCreditAuthorizationParams.merchantAcceptorId - additionalHeaders(transactionSimulateCreditAuthorizationParams.additionalHeaders) - additionalQueryParams( - transactionSimulateCreditAuthorizationParams.additionalQueryParams - ) - additionalBodyProperties( - transactionSimulateCreditAuthorizationParams.additionalBodyProperties - ) + amount = transactionSimulateCreditAuthorizationParams.amount + descriptor = transactionSimulateCreditAuthorizationParams.descriptor + pan = transactionSimulateCreditAuthorizationParams.pan + mcc = transactionSimulateCreditAuthorizationParams.mcc + merchantAcceptorId = transactionSimulateCreditAuthorizationParams.merchantAcceptorId + additionalHeaders = + transactionSimulateCreditAuthorizationParams.additionalHeaders.toBuilder() + additionalQueryParams = + transactionSimulateCreditAuthorizationParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + transactionSimulateCreditAuthorizationParams.additionalBodyProperties.toMutableMap() } /** @@ -406,4 +391,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionSimulateCreditAuthorizationParams && amount == other.amount && descriptor == other.descriptor && pan == other.pan && mcc == other.mcc && merchantAcceptorId == other.merchantAcceptorId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, descriptor, pan, mcc, merchantAcceptorId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TransactionSimulateCreditAuthorizationParams{amount=$amount, descriptor=$descriptor, pan=$pan, mcc=$mcc, merchantAcceptorId=$merchantAcceptorId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateReturnParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateReturnParams.kt index 909554e7..6961e99a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateReturnParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateReturnParams.kt @@ -31,6 +31,12 @@ constructor( fun pan(): String = pan + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TransactionSimulateReturnBody { return TransactionSimulateReturnBody( amount, @@ -140,25 +146,6 @@ constructor( "TransactionSimulateReturnBody{amount=$amount, descriptor=$descriptor, pan=$pan, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionSimulateReturnParams && amount == other.amount && descriptor == other.descriptor && pan == other.pan && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, descriptor, pan, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TransactionSimulateReturnParams{amount=$amount, descriptor=$descriptor, pan=$pan, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -178,12 +165,14 @@ constructor( internal fun from(transactionSimulateReturnParams: TransactionSimulateReturnParams) = apply { - this.amount = transactionSimulateReturnParams.amount - this.descriptor = transactionSimulateReturnParams.descriptor - this.pan = transactionSimulateReturnParams.pan - additionalHeaders(transactionSimulateReturnParams.additionalHeaders) - additionalQueryParams(transactionSimulateReturnParams.additionalQueryParams) - additionalBodyProperties(transactionSimulateReturnParams.additionalBodyProperties) + amount = transactionSimulateReturnParams.amount + descriptor = transactionSimulateReturnParams.descriptor + pan = transactionSimulateReturnParams.pan + additionalHeaders = transactionSimulateReturnParams.additionalHeaders.toBuilder() + additionalQueryParams = + transactionSimulateReturnParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + transactionSimulateReturnParams.additionalBodyProperties.toMutableMap() } /** Amount (in cents) to authorize. */ @@ -325,4 +314,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionSimulateReturnParams && amount == other.amount && descriptor == other.descriptor && pan == other.pan && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, descriptor, pan, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TransactionSimulateReturnParams{amount=$amount, descriptor=$descriptor, pan=$pan, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateReturnReversalParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateReturnReversalParams.kt index 46d22ca5..5a88223d 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateReturnReversalParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateReturnReversalParams.kt @@ -25,6 +25,12 @@ constructor( fun token(): String = token + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TransactionSimulateReturnReversalBody { return TransactionSimulateReturnReversalBody(token, additionalBodyProperties) } @@ -109,25 +115,6 @@ constructor( "TransactionSimulateReturnReversalBody{token=$token, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionSimulateReturnReversalParams && token == other.token && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TransactionSimulateReturnReversalParams{token=$token, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -146,12 +133,13 @@ constructor( internal fun from( transactionSimulateReturnReversalParams: TransactionSimulateReturnReversalParams ) = apply { - this.token = transactionSimulateReturnReversalParams.token - additionalHeaders(transactionSimulateReturnReversalParams.additionalHeaders) - additionalQueryParams(transactionSimulateReturnReversalParams.additionalQueryParams) - additionalBodyProperties( - transactionSimulateReturnReversalParams.additionalBodyProperties - ) + token = transactionSimulateReturnReversalParams.token + additionalHeaders = + transactionSimulateReturnReversalParams.additionalHeaders.toBuilder() + additionalQueryParams = + transactionSimulateReturnReversalParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + transactionSimulateReturnReversalParams.additionalBodyProperties.toMutableMap() } /** The transaction token returned from the /v1/simulate/authorize response. */ @@ -285,4 +273,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionSimulateReturnReversalParams && token == other.token && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TransactionSimulateReturnReversalParams{token=$token, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateVoidParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateVoidParams.kt index 517e57f1..514618d2 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateVoidParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransactionSimulateVoidParams.kt @@ -35,6 +35,12 @@ constructor( fun type(): Type? = type + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TransactionSimulateVoidBody { return TransactionSimulateVoidBody( token, @@ -157,25 +163,6 @@ constructor( "TransactionSimulateVoidBody{token=$token, amount=$amount, type=$type, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransactionSimulateVoidParams && token == other.token && amount == other.amount && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, amount, type, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TransactionSimulateVoidParams{token=$token, amount=$amount, type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -194,12 +181,13 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(transactionSimulateVoidParams: TransactionSimulateVoidParams) = apply { - this.token = transactionSimulateVoidParams.token - this.amount = transactionSimulateVoidParams.amount - this.type = transactionSimulateVoidParams.type - additionalHeaders(transactionSimulateVoidParams.additionalHeaders) - additionalQueryParams(transactionSimulateVoidParams.additionalQueryParams) - additionalBodyProperties(transactionSimulateVoidParams.additionalBodyProperties) + token = transactionSimulateVoidParams.token + amount = transactionSimulateVoidParams.amount + type = transactionSimulateVoidParams.type + additionalHeaders = transactionSimulateVoidParams.additionalHeaders.toBuilder() + additionalQueryParams = transactionSimulateVoidParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + transactionSimulateVoidParams.additionalBodyProperties.toMutableMap() } /** The transaction token returned from the /v1/simulate/authorize response. */ @@ -405,4 +393,17 @@ constructor( fun asString(): String = _value().asStringOrThrow() } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransactionSimulateVoidParams && token == other.token && amount == other.amount && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(token, amount, type, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TransactionSimulateVoidParams{token=$token, amount=$amount, type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransferCreateParams.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransferCreateParams.kt index fcb8a85d..eabff97a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransferCreateParams.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/models/TransferCreateParams.kt @@ -37,6 +37,12 @@ constructor( fun memo(): String? = memo + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + internal fun getBody(): TransferCreateBody { return TransferCreateBody( amount, @@ -190,25 +196,6 @@ constructor( "TransferCreateBody{amount=$amount, from=$from, to=$to, token=$token, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Headers = additionalHeaders - - fun _additionalQueryParams(): QueryParams = additionalQueryParams - - fun _additionalBodyProperties(): Map = additionalBodyProperties - - override fun equals(other: Any?): Boolean { - if (this === other) { - return true - } - - return /* spotless:off */ other is TransferCreateParams && amount == other.amount && from == other.from && to == other.to && token == other.token && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ - } - - override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, from, to, token, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ - - override fun toString() = - "TransferCreateParams{amount=$amount, from=$from, to=$to, token=$token, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" - fun toBuilder() = Builder().from(this) companion object { @@ -229,14 +216,14 @@ constructor( private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(transferCreateParams: TransferCreateParams) = apply { - this.amount = transferCreateParams.amount - this.from = transferCreateParams.from - this.to = transferCreateParams.to - this.token = transferCreateParams.token - this.memo = transferCreateParams.memo - additionalHeaders(transferCreateParams.additionalHeaders) - additionalQueryParams(transferCreateParams.additionalQueryParams) - additionalBodyProperties(transferCreateParams.additionalBodyProperties) + amount = transferCreateParams.amount + from = transferCreateParams.from + to = transferCreateParams.to + token = transferCreateParams.token + memo = transferCreateParams.memo + additionalHeaders = transferCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = transferCreateParams.additionalQueryParams.toBuilder() + additionalBodyProperties = transferCreateParams.additionalBodyProperties.toMutableMap() } /** @@ -398,4 +385,17 @@ constructor( additionalBodyProperties.toImmutable(), ) } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is TransferCreateParams && amount == other.amount && from == other.from && to == other.to && token == other.token && memo == other.memo && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(amount, from, to, token, memo, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "TransferCreateParams{amount=$amount, from=$from, to=$to, token=$token, memo=$memo, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" }