From 982538c12865ccf2f9d3b5edcbafd7400ca93666 Mon Sep 17 00:00:00 2001 From: Stainless Bot Date: Wed, 6 Nov 2024 23:05:06 +0000 Subject: [PATCH] feat(client)!: replace multimaps with custom types # Migration - Methods that return headers or query params (e.g. headers from exception classes) previously returned `ListMultimap`, but now return custom `Headers` and `QueryParams` types, respectively, instead. If you were referencing `ListMultimap`, then update the referenced types and the referenced methods, which are almost identical in name, but have some differences - Methods that accept individual headers and query params are unchanged. However, they now have additional overloads for passing the new custom `Headers` and `QueryParams` types --- lithic-kotlin-client-okhttp/build.gradle.kts | 1 - .../api/client/okhttp/LithicOkHttpClient.kt | 18 +++ .../client/okhttp/LithicOkHttpClientAsync.kt | 18 +++ .../lithic/api/client/okhttp/OkHttpClient.kt | 25 ++-- lithic-kotlin-core/build.gradle.kts | 1 - .../api/client/LithicClientAsyncImpl.kt | 6 +- .../com/lithic/api/client/LithicClientImpl.kt | 6 +- .../com/lithic/api/core/ClientOptions.kt | 88 ++++++++----- .../main/kotlin/com/lithic/api/core/Utils.kt | 5 - .../lithic/api/core/handlers/ErrorHandler.kt | 4 +- .../com/lithic/api/core/http/HttpRequest.kt | 81 +++++++----- .../com/lithic/api/core/http/HttpResponse.kt | 3 +- .../api/core/http/RetryingHttpClient.kt | 43 ++++--- .../lithic/api/errors/BadRequestException.kt | 4 +- .../api/errors/InternalServerException.kt | 4 +- .../api/errors/LithicServiceException.kt | 6 +- .../lithic/api/errors/NotFoundException.kt | 4 +- .../api/errors/PermissionDeniedException.kt | 4 +- .../lithic/api/errors/RateLimitException.kt | 4 +- .../api/errors/UnauthorizedException.kt | 4 +- .../errors/UnexpectedStatusCodeException.kt | 4 +- .../errors/UnprocessableEntityException.kt | 4 +- .../api/models/AccountHolderCreateParams.kt | 87 +++++++------ .../AccountHolderListDocumentsParams.kt | 87 +++++++------ .../api/models/AccountHolderListParams.kt | 117 ++++++++++-------- .../api/models/AccountHolderResubmitParams.kt | 86 ++++++++----- .../AccountHolderRetrieveDocumentParams.kt | 87 +++++++------ .../api/models/AccountHolderRetrieveParams.kt | 87 +++++++------ ...rSimulateEnrollmentDocumentReviewParams.kt | 86 ++++++++----- ...untHolderSimulateEnrollmentReviewParams.kt | 86 ++++++++----- .../api/models/AccountHolderUpdateParams.kt | 86 ++++++++----- .../AccountHolderUploadDocumentParams.kt | 86 ++++++++----- .../lithic/api/models/AccountListParams.kt | 103 ++++++++------- .../api/models/AccountRetrieveParams.kt | 87 +++++++------ .../AccountRetrieveSpendLimitsParams.kt | 87 +++++++------ .../lithic/api/models/AccountUpdateParams.kt | 86 ++++++++----- .../api/models/AggregateBalanceListParams.kt | 95 ++++++++------ .../api/models/AuthRuleV2ApplyParams.kt | 86 ++++++++----- .../api/models/AuthRuleV2CreateParams.kt | 86 ++++++++----- .../api/models/AuthRuleV2DraftParams.kt | 86 ++++++++----- .../lithic/api/models/AuthRuleV2ListParams.kt | 105 +++++++++------- .../api/models/AuthRuleV2PromoteParams.kt | 86 ++++++++----- .../api/models/AuthRuleV2ReportParams.kt | 86 ++++++++----- .../api/models/AuthRuleV2RetrieveParams.kt | 87 +++++++------ .../api/models/AuthRuleV2UpdateParams.kt | 86 ++++++++----- ...uthStreamEnrollmentRetrieveSecretParams.kt | 87 +++++++------ .../AuthStreamEnrollmentRotateSecretParams.kt | 86 ++++++++----- .../lithic/api/models/BalanceListParams.kt | 102 +++++++++------ .../api/models/BookTransferCreateParams.kt | 86 ++++++++----- .../api/models/BookTransferListParams.kt | 117 ++++++++++-------- .../api/models/BookTransferRetrieveParams.kt | 87 +++++++------ .../api/models/BookTransferReverseParams.kt | 86 ++++++++----- .../models/CardAggregateBalanceListParams.kt | 97 +++++++++------ .../api/models/CardBalanceListParams.kt | 100 +++++++++------ .../com/lithic/api/models/CardCreateParams.kt | 86 ++++++++----- .../com/lithic/api/models/CardEmbedParams.kt | 97 +++++++++------ .../CardFinancialTransactionListParams.kt | 109 +++++++++------- .../CardFinancialTransactionRetrieveParams.kt | 87 +++++++------ .../com/lithic/api/models/CardListParams.kt | 107 +++++++++------- .../api/models/CardProgramListParams.kt | 99 +++++++++------ .../api/models/CardProgramRetrieveParams.kt | 87 +++++++------ .../lithic/api/models/CardProvisionParams.kt | 86 ++++++++----- .../lithic/api/models/CardReissueParams.kt | 86 ++++++++----- .../com/lithic/api/models/CardRenewParams.kt | 86 ++++++++----- .../lithic/api/models/CardRetrieveParams.kt | 87 +++++++------ .../models/CardRetrieveSpendLimitsParams.kt | 87 +++++++------ .../api/models/CardSearchByPanParams.kt | 86 ++++++++----- .../com/lithic/api/models/CardUpdateParams.kt | 86 ++++++++----- .../api/models/ClientApiStatusParams.kt | 88 +++++++------ ...editProductExtendedCreditRetrieveParams.kt | 87 +++++++------ .../api/models/DigitalCardArtListParams.kt | 99 +++++++++------ .../models/DigitalCardArtRetrieveParams.kt | 87 +++++++------ .../lithic/api/models/DisputeCreateParams.kt | 86 ++++++++----- .../api/models/DisputeDeleteEvidenceParams.kt | 86 ++++++++----- .../lithic/api/models/DisputeDeleteParams.kt | 86 ++++++++----- .../DisputeInitiateEvidenceUploadParams.kt | 86 ++++++++----- .../api/models/DisputeListEvidencesParams.kt | 103 ++++++++------- .../lithic/api/models/DisputeListParams.kt | 106 +++++++++------- .../models/DisputeRetrieveEvidenceParams.kt | 87 +++++++------ .../api/models/DisputeRetrieveParams.kt | 87 +++++++------ .../lithic/api/models/DisputeUpdateParams.kt | 86 ++++++++----- .../api/models/EventListAttemptsParams.kt | 105 +++++++++------- .../com/lithic/api/models/EventListParams.kt | 108 +++++++++------- .../lithic/api/models/EventRetrieveParams.kt | 87 +++++++------ .../models/EventSubscriptionCreateParams.kt | 86 ++++++++----- .../models/EventSubscriptionDeleteParams.kt | 86 ++++++++----- .../EventSubscriptionListAttemptsParams.kt | 105 +++++++++------- .../api/models/EventSubscriptionListParams.kt | 99 +++++++++------ .../models/EventSubscriptionRecoverParams.kt | 96 ++++++++------ .../EventSubscriptionReplayMissingParams.kt | 96 ++++++++------ .../models/EventSubscriptionRetrieveParams.kt | 87 +++++++------ .../EventSubscriptionRetrieveSecretParams.kt | 87 +++++++------ .../EventSubscriptionRotateSecretParams.kt | 86 ++++++++----- ...tSubscriptionSendSimulatedExampleParams.kt | 86 ++++++++----- .../models/EventSubscriptionUpdateParams.kt | 86 ++++++++----- .../models/ExternalBankAccountCreateParams.kt | 86 ++++++++----- .../models/ExternalBankAccountListParams.kt | 116 ++++++++++------- ...rnalBankAccountMicroDepositCreateParams.kt | 86 ++++++++----- .../ExternalBankAccountRetrieveParams.kt | 87 +++++++------ ...rnalBankAccountRetryMicroDepositsParams.kt | 86 ++++++++----- .../ExternalBankAccountRetryPrenoteParams.kt | 86 ++++++++----- .../models/ExternalBankAccountUpdateParams.kt | 86 ++++++++----- .../api/models/ExternalPaymentCancelParams.kt | 86 ++++++++----- .../api/models/ExternalPaymentCreateParams.kt | 86 ++++++++----- .../api/models/ExternalPaymentListParams.kt | 115 +++++++++-------- .../models/ExternalPaymentReleaseParams.kt | 86 ++++++++----- .../models/ExternalPaymentRetrieveParams.kt | 87 +++++++------ .../models/ExternalPaymentReverseParams.kt | 86 ++++++++----- .../api/models/ExternalPaymentSettleParams.kt | 86 ++++++++----- .../FinancialAccountBalanceListParams.kt | 100 +++++++++------ .../models/FinancialAccountChargeOffParams.kt | 86 ++++++++----- .../models/FinancialAccountCreateParams.kt | 86 ++++++++----- ...ccountCreditConfigurationRetrieveParams.kt | 87 +++++++------ ...lAccountCreditConfigurationUpdateParams.kt | 86 ++++++++----- .../api/models/FinancialAccountListParams.kt | 99 +++++++++------ .../FinancialAccountLoanTapeListParams.kt | 105 +++++++++------- .../FinancialAccountLoanTapeRetrieveParams.kt | 87 +++++++------ .../models/FinancialAccountRetrieveParams.kt | 87 +++++++------ ...ncialAccountStatementLineItemListParams.kt | 99 +++++++++------ .../FinancialAccountStatementListParams.kt | 105 +++++++++------- ...FinancialAccountStatementRetrieveParams.kt | 87 +++++++------ .../models/FinancialAccountUpdateParams.kt | 86 ++++++++----- .../models/FinancialTransactionListParams.kt | 109 +++++++++------- .../FinancialTransactionRetrieveParams.kt | 87 +++++++------ .../models/ManagementOperationCreateParams.kt | 86 ++++++++----- .../models/ManagementOperationListParams.kt | 111 ++++++++++------- .../ManagementOperationRetrieveParams.kt | 87 +++++++------ .../ManagementOperationReverseParams.kt | 86 ++++++++----- .../lithic/api/models/PaymentCreateParams.kt | 86 ++++++++----- .../lithic/api/models/PaymentListParams.kt | 117 ++++++++++-------- .../api/models/PaymentRetrieveParams.kt | 87 +++++++------ .../lithic/api/models/PaymentRetryParams.kt | 86 ++++++++----- .../api/models/PaymentSimulateActionParams.kt | 86 ++++++++----- .../models/PaymentSimulateReceiptParams.kt | 86 ++++++++----- .../models/PaymentSimulateReleaseParams.kt | 86 ++++++++----- .../api/models/PaymentSimulateReturnParams.kt | 86 ++++++++----- .../ReportSettlementListDetailsParams.kt | 99 +++++++++------ .../models/ReportSettlementSummaryParams.kt | 87 +++++++------ .../ResponderEndpointCheckStatusParams.kt | 95 ++++++++------ .../models/ResponderEndpointCreateParams.kt | 86 ++++++++----- .../models/ResponderEndpointDeleteParams.kt | 94 ++++++++------ .../ThreeDSAuthenticationRetrieveParams.kt | 87 +++++++------ .../ThreeDSAuthenticationSimulateParams.kt | 86 ++++++++----- ...reeDSDecisioningChallengeResponseParams.kt | 86 ++++++++----- .../ThreeDSDecisioningRetrieveSecretParams.kt | 87 +++++++------ .../ThreeDSDecisioningRotateSecretParams.kt | 86 ++++++++----- ...reeDSDecisioningSimulateChallengeParams.kt | 86 ++++++++----- ...isioningSimulateChallengeResponseParams.kt | 86 ++++++++----- .../api/models/TokenizationActivateParams.kt | 86 ++++++++----- .../models/TokenizationDeactivateParams.kt | 86 ++++++++----- ...nizationDecisioningRetrieveSecretParams.kt | 87 +++++++------ ...kenizationDecisioningRotateSecretParams.kt | 86 ++++++++----- .../api/models/TokenizationListParams.kt | 113 ++++++++++------- .../api/models/TokenizationPauseParams.kt | 86 ++++++++----- .../TokenizationResendActivationCodeParams.kt | 86 ++++++++----- .../api/models/TokenizationRetrieveParams.kt | 87 +++++++------ .../api/models/TokenizationSimulateParams.kt | 86 ++++++++----- .../api/models/TokenizationUnpauseParams.kt | 86 ++++++++----- .../TokenizationUpdateDigitalCardArtParams.kt | 86 ++++++++----- ...ionEnhancedCommercialDataRetrieveParams.kt | 87 +++++++------ ...entEnhancedCommercialDataRetrieveParams.kt | 87 +++++++------ .../api/models/TransactionListParams.kt | 109 +++++++++------- .../api/models/TransactionRetrieveParams.kt | 87 +++++++------ ...actionSimulateAuthorizationAdviceParams.kt | 86 ++++++++----- .../TransactionSimulateAuthorizationParams.kt | 86 ++++++++----- .../TransactionSimulateClearingParams.kt | 86 ++++++++----- ...actionSimulateCreditAuthorizationParams.kt | 86 ++++++++----- .../models/TransactionSimulateReturnParams.kt | 86 ++++++++----- ...TransactionSimulateReturnReversalParams.kt | 86 ++++++++----- .../models/TransactionSimulateVoidParams.kt | 86 ++++++++----- .../lithic/api/models/TransferCreateParams.kt | 86 ++++++++----- .../async/AccountHolderServiceAsyncImpl.kt | 40 +++--- .../services/async/AccountServiceAsyncImpl.kt | 16 +-- .../async/AggregateBalanceServiceAsyncImpl.kt | 4 +- .../AuthStreamEnrollmentServiceAsyncImpl.kt | 8 +- .../services/async/BalanceServiceAsyncImpl.kt | 4 +- .../async/BookTransferServiceAsyncImpl.kt | 16 +-- .../async/CardProgramServiceAsyncImpl.kt | 8 +- .../services/async/CardServiceAsyncImpl.kt | 40 +++--- .../async/DigitalCardArtServiceAsyncImpl.kt | 8 +- .../services/async/DisputeServiceAsyncImpl.kt | 36 +++--- .../services/async/EventServiceAsyncImpl.kt | 12 +- .../ExternalBankAccountServiceAsyncImpl.kt | 24 ++-- .../async/ExternalPaymentServiceAsyncImpl.kt | 28 ++--- .../async/FinancialAccountServiceAsyncImpl.kt | 20 +-- .../ManagementOperationServiceAsyncImpl.kt | 16 +-- .../services/async/PaymentServiceAsyncImpl.kt | 32 ++--- .../ResponderEndpointServiceAsyncImpl.kt | 12 +- ...TokenizationDecisioningServiceAsyncImpl.kt | 8 +- .../async/TokenizationServiceAsyncImpl.kt | 36 +++--- .../async/TransactionServiceAsyncImpl.kt | 36 +++--- .../async/TransferServiceAsyncImpl.kt | 4 +- .../async/authRules/V2ServiceAsyncImpl.kt | 32 ++--- .../cards/AggregateBalanceServiceAsyncImpl.kt | 4 +- .../async/cards/BalanceServiceAsyncImpl.kt | 4 +- .../FinancialTransactionServiceAsyncImpl.kt | 8 +- .../ExtendedCreditServiceAsyncImpl.kt | 4 +- .../events/SubscriptionServiceAsyncImpl.kt | 44 +++---- .../MicroDepositServiceAsyncImpl.kt | 4 +- .../BalanceServiceAsyncImpl.kt | 4 +- .../CreditConfigurationServiceAsyncImpl.kt | 8 +- .../FinancialTransactionServiceAsyncImpl.kt | 8 +- .../LoanTapeServiceAsyncImpl.kt | 8 +- .../StatementServiceAsyncImpl.kt | 8 +- .../statements/LineItemServiceAsyncImpl.kt | 4 +- .../reports/SettlementServiceAsyncImpl.kt | 8 +- .../threeDS/AuthenticationServiceAsyncImpl.kt | 8 +- .../threeDS/DecisioningServiceAsyncImpl.kt | 20 +-- .../EnhancedCommercialDataServiceAsyncImpl.kt | 4 +- .../EnhancedCommercialDataServiceAsyncImpl.kt | 4 +- .../blocking/AccountHolderServiceImpl.kt | 40 +++--- .../services/blocking/AccountServiceImpl.kt | 16 +-- .../blocking/AggregateBalanceServiceImpl.kt | 4 +- .../AuthStreamEnrollmentServiceImpl.kt | 8 +- .../services/blocking/BalanceServiceImpl.kt | 4 +- .../blocking/BookTransferServiceImpl.kt | 16 +-- .../blocking/CardProgramServiceImpl.kt | 8 +- .../api/services/blocking/CardServiceImpl.kt | 40 +++--- .../blocking/DigitalCardArtServiceImpl.kt | 8 +- .../services/blocking/DisputeServiceImpl.kt | 36 +++--- .../api/services/blocking/EventServiceImpl.kt | 12 +- .../ExternalBankAccountServiceImpl.kt | 24 ++-- .../blocking/ExternalPaymentServiceImpl.kt | 28 ++--- .../blocking/FinancialAccountServiceImpl.kt | 20 +-- .../ManagementOperationServiceImpl.kt | 16 +-- .../services/blocking/PaymentServiceImpl.kt | 32 ++--- .../blocking/ResponderEndpointServiceImpl.kt | 12 +- .../TokenizationDecisioningServiceImpl.kt | 8 +- .../blocking/TokenizationServiceImpl.kt | 36 +++--- .../blocking/TransactionServiceImpl.kt | 36 +++--- .../services/blocking/TransferServiceImpl.kt | 4 +- .../blocking/authRules/V2ServiceImpl.kt | 32 ++--- .../cards/AggregateBalanceServiceImpl.kt | 4 +- .../blocking/cards/BalanceServiceImpl.kt | 4 +- .../cards/FinancialTransactionServiceImpl.kt | 8 +- .../ExtendedCreditServiceImpl.kt | 4 +- .../events/SubscriptionServiceImpl.kt | 44 +++---- .../MicroDepositServiceImpl.kt | 4 +- .../financialAccounts/BalanceServiceImpl.kt | 4 +- .../CreditConfigurationServiceImpl.kt | 8 +- .../FinancialTransactionServiceImpl.kt | 8 +- .../financialAccounts/LoanTapeServiceImpl.kt | 8 +- .../financialAccounts/StatementServiceImpl.kt | 8 +- .../statements/LineItemServiceImpl.kt | 4 +- .../blocking/reports/SettlementServiceImpl.kt | 8 +- .../threeDS/AuthenticationServiceImpl.kt | 8 +- .../threeDS/DecisioningServiceImpl.kt | 20 +-- .../EnhancedCommercialDataServiceImpl.kt | 4 +- .../EnhancedCommercialDataServiceImpl.kt | 4 +- .../lithic/api/core/http/HttpRequestTest.kt | 22 ---- .../api/models/AccountHolderListParamsTest.kt | 31 ++--- .../api/models/AccountListParamsTest.kt | 19 +-- .../models/AggregateBalanceListParamsTest.kt | 11 +- .../api/models/AuthRuleV2ListParamsTest.kt | 19 +-- .../api/models/BalanceListParamsTest.kt | 15 +-- .../api/models/BookTransferListParamsTest.kt | 34 +++-- .../CardAggregateBalanceListParamsTest.kt | 13 +- .../api/models/CardBalanceListParamsTest.kt | 13 +- .../lithic/api/models/CardEmbedParamsTest.kt | 17 +-- .../CardFinancialTransactionListParamsTest.kt | 32 ++--- .../lithic/api/models/CardListParamsTest.kt | 23 ++-- .../api/models/CardProgramListParamsTest.kt | 15 +-- .../models/DigitalCardArtListParamsTest.kt | 15 +-- .../models/DisputeListEvidencesParamsTest.kt | 19 +-- .../api/models/DisputeListParamsTest.kt | 23 ++-- .../api/models/EventListAttemptsParamsTest.kt | 21 ++-- .../lithic/api/models/EventListParamsTest.kt | 26 ++-- ...EventSubscriptionListAttemptsParamsTest.kt | 21 ++-- .../models/EventSubscriptionListParamsTest.kt | 15 +-- .../EventSubscriptionRecoverParamsTest.kt | 13 +- ...ventSubscriptionReplayMissingParamsTest.kt | 13 +- .../ExternalBankAccountListParamsTest.kt | 33 +++-- .../models/ExternalPaymentListParamsTest.kt | 35 +++--- .../FinancialAccountBalanceListParamsTest.kt | 13 +- .../models/FinancialAccountListParamsTest.kt | 15 +-- .../FinancialAccountLoanTapeListParamsTest.kt | 19 +-- ...lAccountStatementLineItemListParamsTest.kt | 15 +-- ...FinancialAccountStatementListParamsTest.kt | 21 ++-- .../FinancialTransactionListParamsTest.kt | 23 ++-- .../ManagementOperationListParamsTest.kt | 32 +++-- .../api/models/PaymentListParamsTest.kt | 31 ++--- .../ReportSettlementListDetailsParamsTest.kt | 15 +-- .../ResponderEndpointCheckStatusParamsTest.kt | 19 ++- .../ResponderEndpointDeleteParamsTest.kt | 19 ++- .../api/models/TokenizationListParamsTest.kt | 25 ++-- .../api/models/TransactionListParamsTest.kt | 25 ++-- .../lithic/api/services/ErrorHandlingTest.kt | 87 ++++++------- 287 files changed, 9274 insertions(+), 6612 deletions(-) delete mode 100644 lithic-kotlin-core/src/test/kotlin/com/lithic/api/core/http/HttpRequestTest.kt diff --git a/lithic-kotlin-client-okhttp/build.gradle.kts b/lithic-kotlin-client-okhttp/build.gradle.kts index 8af579e4..0aab6a8e 100644 --- a/lithic-kotlin-client-okhttp/build.gradle.kts +++ b/lithic-kotlin-client-okhttp/build.gradle.kts @@ -6,7 +6,6 @@ plugins { dependencies { api(project(":lithic-kotlin-core")) - implementation("com.google.guava:guava:33.0.0-jre") implementation("com.squareup.okhttp3:okhttp:4.12.0") implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0") diff --git a/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/LithicOkHttpClient.kt b/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/LithicOkHttpClient.kt index 4a6f5f4f..b2b93e8b 100644 --- a/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/LithicOkHttpClient.kt +++ b/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/LithicOkHttpClient.kt @@ -6,6 +6,8 @@ import com.fasterxml.jackson.databind.json.JsonMapper import com.lithic.api.client.LithicClient import com.lithic.api.client.LithicClientImpl import com.lithic.api.core.ClientOptions +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import java.net.Proxy import java.time.Clock import java.time.Duration @@ -38,6 +40,8 @@ class LithicOkHttpClient private constructor() { fun clock(clock: Clock) = apply { clientOptions.clock(clock) } + fun headers(headers: Headers) = apply { clientOptions.headers(headers) } + fun headers(headers: Map>) = apply { clientOptions.headers(headers) } @@ -48,6 +52,8 @@ class LithicOkHttpClient private constructor() { clientOptions.putHeaders(name, values) } + fun putAllHeaders(headers: Headers) = apply { clientOptions.putAllHeaders(headers) } + fun putAllHeaders(headers: Map>) = apply { clientOptions.putAllHeaders(headers) } @@ -60,6 +66,8 @@ class LithicOkHttpClient private constructor() { clientOptions.replaceHeaders(name, values) } + fun replaceAllHeaders(headers: Headers) = apply { clientOptions.replaceAllHeaders(headers) } + fun replaceAllHeaders(headers: Map>) = apply { clientOptions.replaceAllHeaders(headers) } @@ -68,6 +76,8 @@ class LithicOkHttpClient private constructor() { fun removeAllHeaders(names: Set) = apply { clientOptions.removeAllHeaders(names) } + fun queryParams(queryParams: QueryParams) = apply { clientOptions.queryParams(queryParams) } + fun queryParams(queryParams: Map>) = apply { clientOptions.queryParams(queryParams) } @@ -80,6 +90,10 @@ class LithicOkHttpClient private constructor() { clientOptions.putQueryParams(key, values) } + fun putAllQueryParams(queryParams: QueryParams) = apply { + clientOptions.putAllQueryParams(queryParams) + } + fun putAllQueryParams(queryParams: Map>) = apply { clientOptions.putAllQueryParams(queryParams) } @@ -92,6 +106,10 @@ class LithicOkHttpClient private constructor() { clientOptions.replaceQueryParams(key, values) } + fun replaceAllQueryParams(queryParams: QueryParams) = apply { + clientOptions.replaceAllQueryParams(queryParams) + } + fun replaceAllQueryParams(queryParams: Map>) = apply { clientOptions.replaceAllQueryParams(queryParams) } diff --git a/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/LithicOkHttpClientAsync.kt b/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/LithicOkHttpClientAsync.kt index 29715cf6..2febb410 100644 --- a/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/LithicOkHttpClientAsync.kt +++ b/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/LithicOkHttpClientAsync.kt @@ -6,6 +6,8 @@ import com.fasterxml.jackson.databind.json.JsonMapper import com.lithic.api.client.LithicClientAsync import com.lithic.api.client.LithicClientAsyncImpl import com.lithic.api.core.ClientOptions +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import java.net.Proxy import java.time.Clock import java.time.Duration @@ -38,6 +40,8 @@ class LithicOkHttpClientAsync private constructor() { fun clock(clock: Clock) = apply { clientOptions.clock(clock) } + fun headers(headers: Headers) = apply { clientOptions.headers(headers) } + fun headers(headers: Map>) = apply { clientOptions.headers(headers) } @@ -48,6 +52,8 @@ class LithicOkHttpClientAsync private constructor() { clientOptions.putHeaders(name, values) } + fun putAllHeaders(headers: Headers) = apply { clientOptions.putAllHeaders(headers) } + fun putAllHeaders(headers: Map>) = apply { clientOptions.putAllHeaders(headers) } @@ -60,6 +66,8 @@ class LithicOkHttpClientAsync private constructor() { clientOptions.replaceHeaders(name, values) } + fun replaceAllHeaders(headers: Headers) = apply { clientOptions.replaceAllHeaders(headers) } + fun replaceAllHeaders(headers: Map>) = apply { clientOptions.replaceAllHeaders(headers) } @@ -68,6 +76,8 @@ class LithicOkHttpClientAsync private constructor() { fun removeAllHeaders(names: Set) = apply { clientOptions.removeAllHeaders(names) } + fun queryParams(queryParams: QueryParams) = apply { clientOptions.queryParams(queryParams) } + fun queryParams(queryParams: Map>) = apply { clientOptions.queryParams(queryParams) } @@ -80,6 +90,10 @@ class LithicOkHttpClientAsync private constructor() { clientOptions.putQueryParams(key, values) } + fun putAllQueryParams(queryParams: QueryParams) = apply { + clientOptions.putAllQueryParams(queryParams) + } + fun putAllQueryParams(queryParams: Map>) = apply { clientOptions.putAllQueryParams(queryParams) } @@ -92,6 +106,10 @@ class LithicOkHttpClientAsync private constructor() { clientOptions.replaceQueryParams(key, values) } + fun replaceAllQueryParams(queryParams: QueryParams) = apply { + clientOptions.replaceAllQueryParams(queryParams) + } + fun replaceAllQueryParams(queryParams: Map>) = apply { clientOptions.replaceAllQueryParams(queryParams) } diff --git a/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/OkHttpClient.kt b/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/OkHttpClient.kt index 03907d3a..5e46b1c1 100644 --- a/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/OkHttpClient.kt +++ b/lithic-kotlin-client-okhttp/src/main/kotlin/com/lithic/api/client/okhttp/OkHttpClient.kt @@ -1,8 +1,7 @@ package com.lithic.api.client.okhttp -import com.google.common.collect.ListMultimap -import com.google.common.collect.MultimapBuilder import com.lithic.api.core.RequestOptions +import com.lithic.api.core.http.Headers import com.lithic.api.core.http.HttpClient import com.lithic.api.core.http.HttpMethod import com.lithic.api.core.http.HttpRequest @@ -16,7 +15,6 @@ import java.time.Duration import kotlinx.coroutines.suspendCancellableCoroutine import okhttp3.Call import okhttp3.Callback -import okhttp3.Headers import okhttp3.HttpUrl import okhttp3.HttpUrl.Companion.toHttpUrl import okhttp3.MediaType @@ -86,7 +84,9 @@ private constructor(private val okHttpClient: okhttp3.OkHttpClient, private val } val builder = Request.Builder().url(toUrl()).method(method.name, body) - headers.forEach(builder::header) + headers.names().forEach { name -> + headers.values(name).forEach { builder.header(name, it) } + } return builder.build() } @@ -98,7 +98,9 @@ private constructor(private val okHttpClient: okhttp3.OkHttpClient, private val val builder = baseUrl.newBuilder() pathSegments.forEach(builder::addPathSegment) - queryParams.forEach(builder::addQueryParameter) + queryParams.keys().forEach { key -> + queryParams.values(key).forEach { builder.addQueryParameter(key, it) } + } return builder.toString() } @@ -124,7 +126,7 @@ private constructor(private val okHttpClient: okhttp3.OkHttpClient, private val return object : HttpResponse { override fun statusCode(): Int = code - override fun headers(): ListMultimap = headers + override fun headers(): Headers = headers override fun body(): InputStream = body!!.byteStream() @@ -132,13 +134,10 @@ private constructor(private val okHttpClient: okhttp3.OkHttpClient, private val } } - private fun Headers.toHeaders(): ListMultimap { - val headers = - MultimapBuilder.treeKeys(String.CASE_INSENSITIVE_ORDER) - .arrayListValues() - .build() - forEach { pair -> headers.put(pair.first, pair.second) } - return headers + private fun okhttp3.Headers.toHeaders(): Headers { + val headersBuilder = Headers.builder() + forEach { (name, value) -> headersBuilder.put(name, value) } + return headersBuilder.build() } companion object { diff --git a/lithic-kotlin-core/build.gradle.kts b/lithic-kotlin-core/build.gradle.kts index dbaf6547..b1c13010 100644 --- a/lithic-kotlin-core/build.gradle.kts +++ b/lithic-kotlin-core/build.gradle.kts @@ -6,7 +6,6 @@ plugins { dependencies { api("com.fasterxml.jackson.core:jackson-core:2.14.3") api("com.fasterxml.jackson.core:jackson-databind:2.14.3") - api("com.google.guava:guava:33.0.0-jre") implementation("com.fasterxml.jackson.core:jackson-annotations:2.14.3") implementation("com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.14.3") diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/client/LithicClientAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/client/LithicClientAsyncImpl.kt index fa80b0b8..0eb05e2b 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/client/LithicClientAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/client/LithicClientAsyncImpl.kt @@ -21,7 +21,7 @@ constructor( ) : LithicClientAsync { private val clientOptionsWithUserAgent = - if (clientOptions.headers.containsKey("User-Agent")) clientOptions + if (clientOptions.headers.names().contains("User-Agent")) clientOptions else clientOptions .toBuilder() @@ -196,9 +196,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "status") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/client/LithicClientImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/client/LithicClientImpl.kt index a637d6bd..a85e21f1 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/client/LithicClientImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/client/LithicClientImpl.kt @@ -21,7 +21,7 @@ constructor( ) : LithicClient { private val clientOptionsWithUserAgent = - if (clientOptions.headers.containsKey("User-Agent")) clientOptions + if (clientOptions.headers.names().contains("User-Agent")) clientOptions else clientOptions .toBuilder() @@ -181,9 +181,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "status") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/ClientOptions.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/ClientOptions.kt index a3bc16bf..7f7c06b9 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/ClientOptions.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/ClientOptions.kt @@ -3,10 +3,10 @@ package com.lithic.api.core import com.fasterxml.jackson.databind.json.JsonMapper -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers import com.lithic.api.core.http.HttpClient import com.lithic.api.core.http.PhantomReachableClosingHttpClient +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.http.RetryingHttpClient import java.time.Clock @@ -17,8 +17,8 @@ private constructor( val jsonMapper: JsonMapper, val clock: Clock, val baseUrl: String, - val headers: ListMultimap, - val queryParams: ListMultimap, + val headers: Headers, + val queryParams: QueryParams, val responseValidation: Boolean, val maxRetries: Int, val apiKey: String, @@ -44,8 +44,8 @@ private constructor( private var jsonMapper: JsonMapper = jsonMapper() private var clock: Clock = Clock.systemUTC() private var baseUrl: String = PRODUCTION_URL - private var headers: ListMultimap = ArrayListMultimap.create() - private var queryParams: ListMultimap = ArrayListMultimap.create() + private var headers: Headers.Builder = Headers.builder() + private var queryParams: QueryParams.Builder = QueryParams.builder() private var responseValidation: Boolean = false private var maxRetries: Int = 2 private var apiKey: String? = null @@ -56,8 +56,8 @@ private constructor( jsonMapper = clientOptions.jsonMapper clock = clientOptions.clock baseUrl = clientOptions.baseUrl - headers = ArrayListMultimap.create(clientOptions.headers) - queryParams = ArrayListMultimap.create(clientOptions.queryParams) + headers = clientOptions.headers.toBuilder() + queryParams = clientOptions.queryParams.toBuilder() responseValidation = clientOptions.responseValidation maxRetries = clientOptions.maxRetries apiKey = clientOptions.apiKey @@ -72,6 +72,11 @@ private constructor( fun baseUrl(baseUrl: String) = apply { this.baseUrl = baseUrl } + fun headers(headers: Headers) = apply { + this.headers.clear() + putAllHeaders(headers) + } + fun headers(headers: Map>) = apply { this.headers.clear() putAllHeaders(headers) @@ -79,29 +84,34 @@ private constructor( fun putHeader(name: String, value: String) = apply { headers.put(name, value) } - fun putHeaders(name: String, values: Iterable) = apply { - headers.putAll(name, values) - } + fun putHeaders(name: String, values: Iterable) = apply { headers.put(name, values) } + + fun putAllHeaders(headers: Headers) = apply { this.headers.putAll(headers) } fun putAllHeaders(headers: Map>) = apply { - headers.forEach(::putHeaders) + this.headers.putAll(headers) } - fun replaceHeaders(name: String, value: String) = apply { - headers.replaceValues(name, listOf(value)) - } + fun replaceHeaders(name: String, value: String) = apply { headers.replace(name, value) } fun replaceHeaders(name: String, values: Iterable) = apply { - headers.replaceValues(name, values) + headers.replace(name, values) } + fun replaceAllHeaders(headers: Headers) = apply { this.headers.replaceAll(headers) } + fun replaceAllHeaders(headers: Map>) = apply { - headers.forEach(::replaceHeaders) + this.headers.replaceAll(headers) } - fun removeHeaders(name: String) = apply { headers.removeAll(name) } + fun removeHeaders(name: String) = apply { headers.remove(name) } - fun removeAllHeaders(names: Set) = apply { names.forEach(::removeHeaders) } + fun removeAllHeaders(names: Set) = apply { headers.removeAll(names) } + + fun queryParams(queryParams: QueryParams) = apply { + this.queryParams.clear() + putAllQueryParams(queryParams) + } fun queryParams(queryParams: Map>) = apply { this.queryParams.clear() @@ -111,28 +121,36 @@ private constructor( fun putQueryParam(key: String, value: String) = apply { queryParams.put(key, value) } fun putQueryParams(key: String, values: Iterable) = apply { - queryParams.putAll(key, values) + queryParams.put(key, values) + } + + fun putAllQueryParams(queryParams: QueryParams) = apply { + this.queryParams.putAll(queryParams) } fun putAllQueryParams(queryParams: Map>) = apply { - queryParams.forEach(::putQueryParams) + this.queryParams.putAll(queryParams) } fun replaceQueryParams(key: String, value: String) = apply { - queryParams.replaceValues(key, listOf(value)) + queryParams.replace(key, value) } fun replaceQueryParams(key: String, values: Iterable) = apply { - queryParams.replaceValues(key, values) + queryParams.replace(key, values) + } + + fun replaceAllQueryParams(queryParams: QueryParams) = apply { + this.queryParams.replaceAll(queryParams) } fun replaceAllQueryParams(queryParams: Map>) = apply { - queryParams.forEach(::replaceQueryParams) + this.queryParams.replaceAll(queryParams) } - fun removeQueryParams(key: String) = apply { queryParams.removeAll(key) } + fun removeQueryParams(key: String) = apply { queryParams.remove(key) } - fun removeAllQueryParams(keys: Set) = apply { keys.forEach(::removeQueryParams) } + fun removeAllQueryParams(keys: Set) = apply { queryParams.removeAll(keys) } fun responseValidation(responseValidation: Boolean) = apply { this.responseValidation = responseValidation @@ -153,8 +171,8 @@ private constructor( checkNotNull(httpClient) { "`httpClient` is required but was not set" } checkNotNull(apiKey) { "`apiKey` is required but was not set" } - val headers = ArrayListMultimap.create() - val queryParams = ArrayListMultimap.create() + val headers = Headers.builder() + val queryParams = QueryParams.builder() headers.put("X-Stainless-Lang", "kotlin") headers.put("X-Stainless-Arch", getOsArch()) headers.put("X-Stainless-OS", getOsName()) @@ -163,11 +181,13 @@ private constructor( headers.put("X-Stainless-Runtime", "JRE") headers.put("X-Stainless-Runtime-Version", getJavaVersion()) headers.put("X-Lithic-Pagination", "cursor") - if (!apiKey.isNullOrEmpty()) { - headers.put("Authorization", apiKey) + apiKey?.let { + if (!it.isEmpty()) { + headers.put("Authorization", it) + } } - this.headers.asMap().forEach(headers::replaceValues) - this.queryParams.asMap().forEach(queryParams::replaceValues) + headers.replaceAll(this.headers.build()) + queryParams.replaceAll(this.queryParams.build()) return ClientOptions( httpClient!!, @@ -181,8 +201,8 @@ private constructor( jsonMapper, clock, baseUrl, - headers.toImmutable(), - queryParams.toImmutable(), + headers.build(), + queryParams.build(), responseValidation, maxRetries, apiKey!!, diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/Utils.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/Utils.kt index 3f8e2cc3..063d372c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/Utils.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/Utils.kt @@ -2,8 +2,6 @@ package com.lithic.api.core -import com.google.common.collect.ImmutableListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.errors.LithicInvalidDataException import java.util.Collections import java.util.SortedMap @@ -21,7 +19,4 @@ internal fun , V> SortedMap.toImmutable(): SortedMap ListMultimap.toImmutable(): ListMultimap = - ImmutableListMultimap.copyOf(this) - internal interface Enum diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/handlers/ErrorHandler.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/handlers/ErrorHandler.kt index 12a29a4c..c946de64 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/handlers/ErrorHandler.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/handlers/ErrorHandler.kt @@ -3,7 +3,7 @@ package com.lithic.api.core.handlers import com.fasterxml.jackson.databind.json.JsonMapper -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers import com.lithic.api.core.http.HttpResponse import com.lithic.api.core.http.HttpResponse.Handler import com.lithic.api.errors.BadRequestException @@ -114,7 +114,7 @@ private fun HttpResponse.buffered(): HttpResponse { return object : HttpResponse { override fun statusCode(): Int = this@buffered.statusCode() - override fun headers(): ListMultimap = this@buffered.headers() + override fun headers(): Headers = this@buffered.headers() override fun body(): InputStream = ByteArrayInputStream(body) diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/HttpRequest.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/HttpRequest.kt index a84ba522..94e85da3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/HttpRequest.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/HttpRequest.kt @@ -1,8 +1,5 @@ package com.lithic.api.core.http -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap -import com.google.common.collect.MultimapBuilder import com.lithic.api.core.toImmutable class HttpRequest @@ -10,11 +7,13 @@ private constructor( val method: HttpMethod, val url: String?, val pathSegments: List, - val headers: ListMultimap, - val queryParams: ListMultimap, + val headers: Headers, + val queryParams: QueryParams, val body: HttpRequestBody?, ) { + fun toBuilder(): Builder = Builder().from(this) + override fun toString(): String = "HttpRequest{method=$method, url=$url, pathSegments=$pathSegments, headers=$headers, queryParams=$queryParams, body=$body}" @@ -27,11 +26,19 @@ private constructor( private var method: HttpMethod? = null private var url: String? = null private var pathSegments: MutableList = mutableListOf() - private var headers: ListMultimap = - MultimapBuilder.treeKeys(String.CASE_INSENSITIVE_ORDER).arrayListValues().build() - private var queryParams: ListMultimap = ArrayListMultimap.create() + private var headers: Headers.Builder = Headers.builder() + private var queryParams: QueryParams.Builder = QueryParams.builder() private var body: HttpRequestBody? = null + internal fun from(request: HttpRequest) = apply { + method = request.method + url = request.url + pathSegments = request.pathSegments.toMutableList() + headers = request.headers.toBuilder() + queryParams = request.queryParams.toBuilder() + body = request.body + } + fun method(method: HttpMethod) = apply { this.method = method } fun url(url: String) = apply { this.url = url } @@ -42,6 +49,11 @@ private constructor( this.pathSegments.addAll(pathSegments) } + fun headers(headers: Headers) = apply { + this.headers.clear() + putAllHeaders(headers) + } + fun headers(headers: Map>) = apply { this.headers.clear() putAllHeaders(headers) @@ -49,29 +61,34 @@ private constructor( fun putHeader(name: String, value: String) = apply { headers.put(name, value) } - fun putHeaders(name: String, values: Iterable) = apply { - headers.putAll(name, values) - } + fun putHeaders(name: String, values: Iterable) = apply { headers.put(name, values) } + + fun putAllHeaders(headers: Headers) = apply { this.headers.putAll(headers) } fun putAllHeaders(headers: Map>) = apply { - headers.forEach(::putHeaders) + this.headers.putAll(headers) } - fun replaceHeaders(name: String, value: String) = apply { - headers.replaceValues(name, listOf(value)) - } + fun replaceHeaders(name: String, value: String) = apply { headers.replace(name, value) } fun replaceHeaders(name: String, values: Iterable) = apply { - headers.replaceValues(name, values) + headers.replace(name, values) } + fun replaceAllHeaders(headers: Headers) = apply { this.headers.replaceAll(headers) } + fun replaceAllHeaders(headers: Map>) = apply { - headers.forEach(::replaceHeaders) + this.headers.replaceAll(headers) } - fun removeHeaders(name: String) = apply { headers.removeAll(name) } + fun removeHeaders(name: String) = apply { headers.remove(name) } + + fun removeAllHeaders(names: Set) = apply { headers.removeAll(names) } - fun removeAllHeaders(names: Set) = apply { names.forEach(::removeHeaders) } + fun queryParams(queryParams: QueryParams) = apply { + this.queryParams.clear() + putAllQueryParams(queryParams) + } fun queryParams(queryParams: Map>) = apply { this.queryParams.clear() @@ -81,28 +98,36 @@ private constructor( fun putQueryParam(key: String, value: String) = apply { queryParams.put(key, value) } fun putQueryParams(key: String, values: Iterable) = apply { - queryParams.putAll(key, values) + queryParams.put(key, values) + } + + fun putAllQueryParams(queryParams: QueryParams) = apply { + this.queryParams.putAll(queryParams) } fun putAllQueryParams(queryParams: Map>) = apply { - queryParams.forEach(::putQueryParams) + this.queryParams.putAll(queryParams) } fun replaceQueryParams(key: String, value: String) = apply { - queryParams.replaceValues(key, listOf(value)) + queryParams.replace(key, value) } fun replaceQueryParams(key: String, values: Iterable) = apply { - queryParams.replaceValues(key, values) + queryParams.replace(key, values) + } + + fun replaceAllQueryParams(queryParams: QueryParams) = apply { + this.queryParams.replaceAll(queryParams) } fun replaceAllQueryParams(queryParams: Map>) = apply { - queryParams.forEach(::replaceQueryParams) + this.queryParams.replaceAll(queryParams) } - fun removeQueryParams(key: String) = apply { queryParams.removeAll(key) } + fun removeQueryParams(key: String) = apply { queryParams.remove(key) } - fun removeAllQueryParams(keys: Set) = apply { keys.forEach(::removeQueryParams) } + fun removeAllQueryParams(keys: Set) = apply { queryParams.removeAll(keys) } fun body(body: HttpRequestBody) = apply { this.body = body } @@ -111,8 +136,8 @@ private constructor( checkNotNull(method) { "`method` is required but was not set" }, url, pathSegments.toImmutable(), - headers, - queryParams.toImmutable(), + headers.build(), + queryParams.build(), body, ) } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/HttpResponse.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/HttpResponse.kt index dde2105b..00878957 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/HttpResponse.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/HttpResponse.kt @@ -1,6 +1,5 @@ package com.lithic.api.core.http -import com.google.common.collect.ListMultimap import java.io.InputStream import java.lang.AutoCloseable @@ -8,7 +7,7 @@ interface HttpResponse : AutoCloseable { fun statusCode(): Int - fun headers(): ListMultimap + fun headers(): Headers fun body(): InputStream diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/RetryingHttpClient.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/RetryingHttpClient.kt index bc790ede..0cf36993 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/RetryingHttpClient.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/core/http/RetryingHttpClient.kt @@ -33,21 +33,22 @@ private constructor( return httpClient.execute(request, requestOptions) } - maybeAddIdempotencyHeader(request) + var modifiedRequest = maybeAddIdempotencyHeader(request) // Don't send the current retry count in the headers if the caller set their own value. - val shouldSendRetryCount = !request.headers.containsKey("x-stainless-retry-count") + val shouldSendRetryCount = + !modifiedRequest.headers.names().contains("X-Stainless-Retry-Count") var retries = 0 while (true) { if (shouldSendRetryCount) { - setRetryCountHeader(request, retries) + modifiedRequest = setRetryCountHeader(modifiedRequest, retries) } val response = try { - val response = httpClient.execute(request, requestOptions) + val response = httpClient.execute(modifiedRequest, requestOptions) if (++retries > maxRetries || !shouldRetry(response)) { return response } @@ -74,21 +75,22 @@ private constructor( return httpClient.executeAsync(request, requestOptions) } - maybeAddIdempotencyHeader(request) + var modifiedRequest = maybeAddIdempotencyHeader(request) // Don't send the current retry count in the headers if the caller set their own value. - val shouldSendRetryCount = !request.headers.containsKey("x-stainless-retry-count") + val shouldSendRetryCount = + !modifiedRequest.headers.names().contains("X-Stainless-Retry-Count") var retries = 0 while (true) { if (shouldSendRetryCount) { - setRetryCountHeader(request, retries) + modifiedRequest = setRetryCountHeader(modifiedRequest, retries) } val response = try { - val response = httpClient.execute(request, requestOptions) + val response = httpClient.execute(modifiedRequest, requestOptions) if (++retries > maxRetries || !shouldRetry(response)) { return response } @@ -114,23 +116,26 @@ private constructor( // the body data aren't available on subsequent attempts. request.body?.repeatable() ?: true - private fun setRetryCountHeader(request: HttpRequest, retries: Int) { - request.headers.removeAll("x-stainless-retry-count") - request.headers.put("x-stainless-retry-count", retries.toString()) - } + private fun setRetryCountHeader(request: HttpRequest, retries: Int): HttpRequest = + request.toBuilder().replaceHeaders("X-Stainless-Retry-Count", retries.toString()).build() private fun idempotencyKey(): String = "stainless-java-retry-${UUID.randomUUID()}" - private fun maybeAddIdempotencyHeader(request: HttpRequest) { - if (idempotencyHeader != null && !request.headers.containsKey(idempotencyHeader)) { - // Set a header to uniquely identify the request when retried - request.headers.put(idempotencyHeader, idempotencyKey()) + private fun maybeAddIdempotencyHeader(request: HttpRequest): HttpRequest { + if (idempotencyHeader == null || request.headers.names().contains(idempotencyHeader)) { + return request } + + return request + .toBuilder() + // Set a header to uniquely identify the request when retried + .putHeader(idempotencyHeader, idempotencyKey()) + .build() } private fun shouldRetry(response: HttpResponse): Boolean { // Note: this is not a standard header - val shouldRetryHeader = response.headers().get("x-should-retry").getOrNull(0) + val shouldRetryHeader = response.headers().values("X-Should-Retry").getOrNull(0) val statusCode = response.statusCode() return when { @@ -162,11 +167,11 @@ private constructor( ?.headers() ?.let { headers -> headers - .get("Retry-After-Ms") + .values("Retry-After-Ms") .getOrNull(0) ?.toFloatOrNull() ?.times(TimeUnit.MILLISECONDS.toNanos(1)) - ?: headers.get("Retry-After").getOrNull(0)?.let { retryAfter -> + ?: headers.values("Retry-After").getOrNull(0)?.let { retryAfter -> retryAfter.toFloatOrNull()?.times(TimeUnit.SECONDS.toNanos(1)) ?: try { ChronoUnit.MILLIS.between( diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/BadRequestException.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/BadRequestException.kt index f7f287f9..9ff0460d 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/BadRequestException.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/BadRequestException.kt @@ -1,9 +1,9 @@ package com.lithic.api.errors -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers class BadRequestException( - headers: ListMultimap, + headers: Headers, body: String, error: LithicError, ) : LithicServiceException(400, headers, body, error) diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/InternalServerException.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/InternalServerException.kt index e30b1e4c..ea033318 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/InternalServerException.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/InternalServerException.kt @@ -1,10 +1,10 @@ package com.lithic.api.errors -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers class InternalServerException( statusCode: Int, - headers: ListMultimap, + headers: Headers, body: String, error: LithicError, ) : LithicServiceException(statusCode, headers, body, error) diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/LithicServiceException.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/LithicServiceException.kt index 61ee0f57..be4a6053 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/LithicServiceException.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/LithicServiceException.kt @@ -1,10 +1,10 @@ package com.lithic.api.errors -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers abstract class LithicServiceException( private val statusCode: Int, - private val headers: ListMultimap, + private val headers: Headers, private val body: String, private val error: LithicError, message: String = "$statusCode: $error", @@ -13,7 +13,7 @@ abstract class LithicServiceException( fun statusCode(): Int = statusCode - fun headers(): ListMultimap = headers + fun headers(): Headers = headers fun body(): String = body diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/NotFoundException.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/NotFoundException.kt index 619b58e4..768bdcea 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/NotFoundException.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/NotFoundException.kt @@ -1,9 +1,9 @@ package com.lithic.api.errors -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers class NotFoundException( - headers: ListMultimap, + headers: Headers, body: String, error: LithicError, ) : LithicServiceException(404, headers, body, error) diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/PermissionDeniedException.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/PermissionDeniedException.kt index 232df864..e322aef0 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/PermissionDeniedException.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/PermissionDeniedException.kt @@ -1,9 +1,9 @@ package com.lithic.api.errors -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers class PermissionDeniedException( - headers: ListMultimap, + headers: Headers, body: String, error: LithicError, ) : LithicServiceException(403, headers, body, error) diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/RateLimitException.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/RateLimitException.kt index 8a40ee83..fe2d1de2 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/RateLimitException.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/RateLimitException.kt @@ -1,9 +1,9 @@ package com.lithic.api.errors -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers class RateLimitException( - headers: ListMultimap, + headers: Headers, body: String, error: LithicError, ) : LithicServiceException(429, headers, body, error) diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnauthorizedException.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnauthorizedException.kt index dfeeacd3..dfce32d3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnauthorizedException.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnauthorizedException.kt @@ -1,9 +1,9 @@ package com.lithic.api.errors -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers class UnauthorizedException( - headers: ListMultimap, + headers: Headers, body: String, error: LithicError, ) : LithicServiceException(401, headers, body, error) diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnexpectedStatusCodeException.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnexpectedStatusCodeException.kt index 83c67459..b7698dc3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnexpectedStatusCodeException.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnexpectedStatusCodeException.kt @@ -1,10 +1,10 @@ package com.lithic.api.errors -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers class UnexpectedStatusCodeException( statusCode: Int, - headers: ListMultimap, + headers: Headers, body: String, error: LithicError, ) : LithicServiceException(statusCode, headers, body, error) diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnprocessableEntityException.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnprocessableEntityException.kt index a02c68b6..04fc9935 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnprocessableEntityException.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/errors/UnprocessableEntityException.kt @@ -1,9 +1,9 @@ package com.lithic.api.errors -import com.google.common.collect.ListMultimap +import com.lithic.api.core.http.Headers class UnprocessableEntityException( - headers: ListMultimap, + headers: Headers, body: String, error: LithicError, ) : LithicServiceException(422, headers, body, error) 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 ff982e12..68679379 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 @@ -9,14 +9,13 @@ import com.fasterxml.jackson.databind.SerializerProvider import com.fasterxml.jackson.databind.annotation.JsonDeserialize import com.fasterxml.jackson.databind.annotation.JsonSerialize import com.fasterxml.jackson.module.kotlin.jacksonTypeRef -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.BaseDeserializer import com.lithic.api.core.BaseSerializer import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect import com.lithic.api.core.getOrThrow -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.util.Objects @@ -26,8 +25,8 @@ constructor( private val kyb: Kyb?, private val kyc: Kyc?, private val kycExempt: KycExempt?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun kyb(): Kyb? = kyb @@ -44,9 +43,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(using = AccountHolderCreateBody.Deserializer::class) @JsonSerialize(using = AccountHolderCreateBody.Serializer::class) @@ -169,9 +168,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -201,8 +200,8 @@ constructor( private var kyb: Kyb? = null private var kyc: Kyc? = null private var kycExempt: KycExempt? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountHolderCreateParams: AccountHolderCreateParams) = apply { this.kyb = accountHolderCreateParams.kyb @@ -230,6 +229,11 @@ constructor( this.kycExempt = kycExempt } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -240,29 +244,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -275,33 +292,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AccountHolderCreateParams = @@ -309,14 +332,8 @@ constructor( kyb, kyc, kycExempt, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 0970a732..b2728d5f 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class AccountHolderListDocumentsParams constructor( private val accountHolderToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountHolderToken(): String = accountHolderToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var accountHolderToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountHolderListDocumentsParams: AccountHolderListDocumentsParams) = apply { @@ -73,6 +72,11 @@ constructor( this.accountHolderToken = accountHolderToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -83,29 +87,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -118,33 +135,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AccountHolderListDocumentsParams = @@ -152,14 +175,8 @@ constructor( checkNotNull(accountHolderToken) { "`accountHolderToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 783dd797..662a85ca 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import java.time.format.DateTimeFormatter @@ -24,8 +23,8 @@ constructor( private val limit: Long?, private val phoneNumber: String?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun begin(): OffsetDateTime? = begin @@ -50,32 +49,34 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.email?.let { params.put("email", listOf(it.toString())) } + this.email?.let { queryParams.put("email", listOf(it.toString())) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.externalId?.let { params.put("external_id", listOf(it.toString())) } - this.firstName?.let { params.put("first_name", listOf(it.toString())) } - this.lastName?.let { params.put("last_name", listOf(it.toString())) } - this.legalBusinessName?.let { params.put("legal_business_name", listOf(it.toString())) } - this.limit?.let { params.put("limit", listOf(it.toString())) } - this.phoneNumber?.let { params.put("phone_number", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.externalId?.let { queryParams.put("external_id", listOf(it.toString())) } + this.firstName?.let { queryParams.put("first_name", listOf(it.toString())) } + this.lastName?.let { queryParams.put("last_name", listOf(it.toString())) } + this.legalBusinessName?.let { + queryParams.put("legal_business_name", listOf(it.toString())) + } + this.limit?.let { queryParams.put("limit", listOf(it.toString())) } + this.phoneNumber?.let { queryParams.put("phone_number", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -113,8 +114,8 @@ constructor( private var limit: Long? = null private var phoneNumber: String? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountHolderListParams: AccountHolderListParams) = apply { this.begin = accountHolderListParams.begin @@ -190,6 +191,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -200,29 +206,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -235,33 +254,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AccountHolderListParams = @@ -277,14 +302,8 @@ constructor( limit, phoneNumber, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 860fb338..0ae64425 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -25,8 +25,8 @@ constructor( private val individual: Individual, private val tosTimestamp: String, private val workflow: Workflow, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -47,9 +47,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -169,9 +169,9 @@ constructor( "AccountHolderResubmitBody{individual=$individual, tosTimestamp=$tosTimestamp, workflow=$workflow, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -204,8 +204,8 @@ constructor( private var individual: Individual? = null private var tosTimestamp: String? = null private var workflow: Workflow? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(accountHolderResubmitParams: AccountHolderResubmitParams) = apply { @@ -236,6 +236,11 @@ constructor( fun workflow(workflow: Workflow) = apply { this.workflow = workflow } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -246,29 +251,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -281,33 +299,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -332,14 +356,8 @@ constructor( checkNotNull(individual) { "`individual` is required but was not set" }, checkNotNull(tosTimestamp) { "`tosTimestamp` is required but was not set" }, checkNotNull(workflow) { "`workflow` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 8daf26c4..d4068d24 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -13,17 +12,17 @@ class AccountHolderRetrieveDocumentParams constructor( private val accountHolderToken: String, private val documentToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountHolderToken(): String = accountHolderToken fun documentToken(): String = documentToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -33,9 +32,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -64,8 +63,8 @@ constructor( private var accountHolderToken: String? = null private var documentToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( accountHolderRetrieveDocumentParams: AccountHolderRetrieveDocumentParams @@ -82,6 +81,11 @@ constructor( fun documentToken(documentToken: String) = apply { this.documentToken = documentToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -92,29 +96,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -127,33 +144,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AccountHolderRetrieveDocumentParams = @@ -162,14 +185,8 @@ constructor( "`accountHolderToken` is required but was not set" }, checkNotNull(documentToken) { "`documentToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 7b003bf9..d0011701 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class AccountHolderRetrieveParams constructor( private val accountHolderToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountHolderToken(): String = accountHolderToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var accountHolderToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountHolderRetrieveParams: AccountHolderRetrieveParams) = apply { this.accountHolderToken = accountHolderRetrieveParams.accountHolderToken @@ -72,6 +71,11 @@ constructor( this.accountHolderToken = accountHolderToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -82,29 +86,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -117,33 +134,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AccountHolderRetrieveParams = @@ -151,14 +174,8 @@ constructor( checkNotNull(accountHolderToken) { "`accountHolderToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 b48bd876..6f7b67d2 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -25,8 +25,8 @@ constructor( private val status: Status, private val acceptedEntityStatusReasons: List?, private val statusReason: DocumentUploadStatusReasons?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -48,9 +48,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = AccountHolderSimulateEnrollmentDocumentReviewBody.Builder::class) @NoAutoDetect @@ -186,9 +186,9 @@ constructor( "AccountHolderSimulateEnrollmentDocumentReviewBody{documentUploadToken=$documentUploadToken, status=$status, acceptedEntityStatusReasons=$acceptedEntityStatusReasons, statusReason=$statusReason, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -221,8 +221,8 @@ constructor( private var status: Status? = null private var acceptedEntityStatusReasons: MutableList = mutableListOf() private var statusReason: DocumentUploadStatusReasons? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -273,6 +273,11 @@ constructor( this.statusReason = statusReason } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -283,29 +288,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -318,33 +336,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -370,14 +394,8 @@ constructor( if (acceptedEntityStatusReasons.size == 0) null else acceptedEntityStatusReasons.toImmutable(), statusReason, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 26a9fe97..26f0cc40 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -24,8 +24,8 @@ constructor( private val accountHolderToken: String?, private val status: Status?, private val statusReasons: List?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -44,9 +44,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = AccountHolderSimulateEnrollmentReviewBody.Builder::class) @NoAutoDetect @@ -160,9 +160,9 @@ constructor( "AccountHolderSimulateEnrollmentReviewBody{accountHolderToken=$accountHolderToken, status=$status, statusReasons=$statusReasons, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -194,8 +194,8 @@ constructor( private var accountHolderToken: String? = null private var status: Status? = null private var statusReasons: MutableList = mutableListOf() - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -238,6 +238,11 @@ constructor( this.statusReasons.add(statusReason) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -248,29 +253,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -283,33 +301,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -331,14 +355,8 @@ constructor( accountHolderToken, status, if (statusReasons.size == 0) null else statusReasons.toImmutable(), - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 ff84d15c..10d75e63 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -21,8 +21,8 @@ constructor( private val businessAccountToken: String?, private val email: String?, private val phoneNumber: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -43,9 +43,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -178,9 +178,9 @@ constructor( "AccountHolderUpdateBody{businessAccountToken=$businessAccountToken, email=$email, phoneNumber=$phoneNumber, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -213,8 +213,8 @@ constructor( private var businessAccountToken: String? = null private var email: String? = null private var phoneNumber: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(accountHolderUpdateParams: AccountHolderUpdateParams) = apply { @@ -253,6 +253,11 @@ constructor( */ fun phoneNumber(phoneNumber: String) = apply { this.phoneNumber = phoneNumber } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -263,29 +268,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -298,33 +316,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -349,14 +373,8 @@ constructor( businessAccountToken, email, phoneNumber, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 18d332b3..30229399 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -24,8 +24,8 @@ constructor( private val accountHolderToken: String, private val documentType: DocumentType, private val entityToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -43,9 +43,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -146,9 +146,9 @@ constructor( "AccountHolderUploadDocumentBody{documentType=$documentType, entityToken=$entityToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -180,8 +180,8 @@ constructor( private var accountHolderToken: String? = null private var documentType: DocumentType? = null private var entityToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(accountHolderUploadDocumentParams: AccountHolderUploadDocumentParams) = @@ -204,6 +204,11 @@ constructor( /** Globally unique identifier for the entity. */ fun entityToken(entityToken: String) = apply { this.entityToken = entityToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -214,29 +219,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -249,33 +267,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -299,14 +323,8 @@ constructor( }, checkNotNull(documentType) { "`documentType` is required but was not set" }, checkNotNull(entityToken) { "`entityToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 0e92b9a0..dc20b8cb 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import java.time.format.DateTimeFormatter @@ -18,8 +17,8 @@ constructor( private val endingBefore: String?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun begin(): OffsetDateTime? = begin @@ -32,26 +31,26 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -83,8 +82,8 @@ constructor( private var endingBefore: String? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountListParams: AccountListParams) = apply { this.begin = accountListParams.begin @@ -123,6 +122,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -133,29 +137,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -168,33 +185,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AccountListParams = @@ -204,14 +227,8 @@ constructor( endingBefore, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 a607f245..543ed038 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class AccountRetrieveParams constructor( private val accountToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String = accountToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var accountToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountRetrieveParams: AccountRetrieveParams) = apply { this.accountToken = accountRetrieveParams.accountToken @@ -70,6 +69,11 @@ constructor( fun accountToken(accountToken: String) = apply { this.accountToken = accountToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -80,29 +84,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -115,46 +132,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AccountRetrieveParams = AccountRetrieveParams( checkNotNull(accountToken) { "`accountToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 abdfd562..50c2d029 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class AccountRetrieveSpendLimitsParams constructor( private val accountToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String = accountToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var accountToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(accountRetrieveSpendLimitsParams: AccountRetrieveSpendLimitsParams) = apply { @@ -71,6 +70,11 @@ constructor( fun accountToken(accountToken: String) = apply { this.accountToken = accountToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -81,29 +85,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -116,46 +133,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AccountRetrieveSpendLimitsParams = AccountRetrieveSpendLimitsParams( checkNotNull(accountToken) { "`accountToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 97ee4be9..2b47a9c4 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -27,8 +27,8 @@ constructor( private val monthlySpendLimit: Long?, private val state: State?, private val verificationAddress: VerificationAddress?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -55,9 +55,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -231,9 +231,9 @@ constructor( "AccountUpdateBody{dailySpendLimit=$dailySpendLimit, lifetimeSpendLimit=$lifetimeSpendLimit, monthlySpendLimit=$monthlySpendLimit, state=$state, verificationAddress=$verificationAddress, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -268,8 +268,8 @@ constructor( private var monthlySpendLimit: Long? = null private var state: State? = null private var verificationAddress: VerificationAddress? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(accountUpdateParams: AccountUpdateParams) = apply { @@ -326,6 +326,11 @@ constructor( this.verificationAddress = verificationAddress } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -336,29 +341,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -371,33 +389,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -422,14 +446,8 @@ constructor( monthlySpendLimit, state, verificationAddress, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 41b8b33e..05f34436 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.util.Objects @@ -17,26 +16,26 @@ import java.util.Objects class AggregateBalanceListParams constructor( private val financialAccountType: FinancialAccountType?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountType(): FinancialAccountType? = financialAccountType - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.financialAccountType?.let { - params.put("financial_account_type", listOf(it.toString())) + queryParams.put("financial_account_type", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -64,8 +63,8 @@ constructor( class Builder { private var financialAccountType: FinancialAccountType? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(aggregateBalanceListParams: AggregateBalanceListParams) = apply { this.financialAccountType = aggregateBalanceListParams.financialAccountType @@ -78,6 +77,11 @@ constructor( this.financialAccountType = financialAccountType } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -88,29 +92,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -123,46 +140,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AggregateBalanceListParams = AggregateBalanceListParams( financialAccountType, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 d2a0f193..124f3418 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 @@ -12,14 +12,14 @@ import com.fasterxml.jackson.databind.SerializerProvider import com.fasterxml.jackson.databind.annotation.JsonDeserialize import com.fasterxml.jackson.databind.annotation.JsonSerialize import com.fasterxml.jackson.module.kotlin.jacksonTypeRef -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.BaseDeserializer import com.lithic.api.core.BaseSerializer import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect import com.lithic.api.core.getOrThrow +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -31,8 +31,8 @@ constructor( private val applyAuthRuleRequestAccountTokens: ApplyAuthRuleRequestAccountTokens?, private val applyAuthRuleRequestCardTokens: ApplyAuthRuleRequestCardTokens?, private val applyAuthRuleRequestProgramLevel: ApplyAuthRuleRequestProgramLevel?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun authRuleToken(): String = authRuleToken @@ -54,9 +54,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -221,9 +221,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -254,8 +254,8 @@ constructor( private var applyAuthRuleRequestAccountTokens: ApplyAuthRuleRequestAccountTokens? = null private var applyAuthRuleRequestCardTokens: ApplyAuthRuleRequestCardTokens? = null private var applyAuthRuleRequestProgramLevel: ApplyAuthRuleRequestProgramLevel? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(authRuleV2ApplyParams: AuthRuleV2ApplyParams) = apply { this.authRuleToken = authRuleV2ApplyParams.authRuleToken @@ -295,6 +295,11 @@ constructor( this.applyAuthRuleRequestProgramLevel = applyAuthRuleRequestProgramLevel } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -305,29 +310,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -340,33 +358,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AuthRuleV2ApplyParams = @@ -375,14 +399,8 @@ constructor( applyAuthRuleRequestAccountTokens, applyAuthRuleRequestCardTokens, applyAuthRuleRequestProgramLevel, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 8c053825..3326ca05 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 @@ -13,8 +13,6 @@ import com.fasterxml.jackson.databind.SerializerProvider import com.fasterxml.jackson.databind.annotation.JsonDeserialize import com.fasterxml.jackson.databind.annotation.JsonSerialize import com.fasterxml.jackson.module.kotlin.jacksonTypeRef -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.BaseDeserializer import com.lithic.api.core.BaseSerializer import com.lithic.api.core.Enum @@ -24,6 +22,8 @@ import com.lithic.api.core.JsonMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect import com.lithic.api.core.getOrThrow +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -34,8 +34,8 @@ constructor( private val createAuthRuleRequestAccountTokens: CreateAuthRuleRequestAccountTokens?, private val createAuthRuleRequestCardTokens: CreateAuthRuleRequestCardTokens?, private val createAuthRuleRequestProgramLevel: CreateAuthRuleRequestProgramLevel?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun createAuthRuleRequestAccountTokens(): CreateAuthRuleRequestAccountTokens? = @@ -55,9 +55,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(using = AuthRuleV2CreateBody.Deserializer::class) @JsonSerialize(using = AuthRuleV2CreateBody.Serializer::class) @@ -227,9 +227,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -259,8 +259,8 @@ constructor( private var createAuthRuleRequestAccountTokens: CreateAuthRuleRequestAccountTokens? = null private var createAuthRuleRequestCardTokens: CreateAuthRuleRequestCardTokens? = null private var createAuthRuleRequestProgramLevel: CreateAuthRuleRequestProgramLevel? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(authRuleV2CreateParams: AuthRuleV2CreateParams) = apply { this.createAuthRuleRequestAccountTokens = @@ -297,6 +297,11 @@ constructor( this.createAuthRuleRequestProgramLevel = createAuthRuleRequestProgramLevel } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -307,29 +312,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -342,33 +360,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AuthRuleV2CreateParams = @@ -376,14 +400,8 @@ constructor( createAuthRuleRequestAccountTokens, createAuthRuleRequestCardTokens, createAuthRuleRequestProgramLevel, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 ad01ba51..ceddd655 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 @@ -13,8 +13,6 @@ import com.fasterxml.jackson.databind.SerializerProvider import com.fasterxml.jackson.databind.annotation.JsonDeserialize import com.fasterxml.jackson.databind.annotation.JsonSerialize import com.fasterxml.jackson.module.kotlin.jacksonTypeRef -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.BaseDeserializer import com.lithic.api.core.BaseSerializer import com.lithic.api.core.Enum @@ -24,6 +22,8 @@ import com.lithic.api.core.JsonMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect import com.lithic.api.core.getOrThrow +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -33,8 +33,8 @@ class AuthRuleV2DraftParams constructor( private val authRuleToken: String, private val parameters: Parameters?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -46,9 +46,9 @@ constructor( return AuthRuleV2DraftBody(parameters, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -132,9 +132,9 @@ constructor( "AuthRuleV2DraftBody{parameters=$parameters, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -165,8 +165,8 @@ constructor( private var authRuleToken: String? = null private var parameters: Parameters? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(authRuleV2DraftParams: AuthRuleV2DraftParams) = apply { @@ -192,6 +192,11 @@ constructor( this.parameters = Parameters.ofVelocityLimitParams(velocityLimitParams) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -202,29 +207,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -237,33 +255,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -284,14 +308,8 @@ constructor( AuthRuleV2DraftParams( checkNotNull(authRuleToken) { "`authRuleToken` is required but was not set" }, parameters, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 41752fd6..58bcab1f 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -16,8 +15,8 @@ constructor( private val endingBefore: String?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken @@ -30,22 +29,22 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders - - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } - this.cardToken?.let { params.put("card_token", listOf(it.toString())) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getHeaders(): Headers = additionalHeaders + + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } + this.cardToken?.let { queryParams.put("card_token", listOf(it.toString())) } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -77,8 +76,8 @@ constructor( private var endingBefore: String? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(authRuleV2ListParams: AuthRuleV2ListParams) = apply { this.accountToken = authRuleV2ListParams.accountToken @@ -111,6 +110,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -121,29 +125,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -156,33 +173,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AuthRuleV2ListParams = @@ -192,14 +215,8 @@ constructor( endingBefore, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 6fb3d00b..dfa786fa 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class AuthRuleV2PromoteParams constructor( private val authRuleToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var authRuleToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(authRuleV2PromoteParams: AuthRuleV2PromoteParams) = apply { @@ -80,6 +80,11 @@ constructor( fun authRuleToken(authRuleToken: String) = apply { this.authRuleToken = authRuleToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -90,29 +95,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -125,33 +143,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -171,14 +195,8 @@ constructor( fun build(): AuthRuleV2PromoteParams = AuthRuleV2PromoteParams( checkNotNull(authRuleToken) { "`authRuleToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 c4ef2d31..c1bd62cd 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class AuthRuleV2ReportParams constructor( private val authRuleToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var authRuleToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(authRuleV2ReportParams: AuthRuleV2ReportParams) = apply { @@ -80,6 +80,11 @@ constructor( fun authRuleToken(authRuleToken: String) = apply { this.authRuleToken = authRuleToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -90,29 +95,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -125,33 +143,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -171,14 +195,8 @@ constructor( fun build(): AuthRuleV2ReportParams = AuthRuleV2ReportParams( checkNotNull(authRuleToken) { "`authRuleToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 1cbb395a..b75bc554 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class AuthRuleV2RetrieveParams constructor( private val authRuleToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun authRuleToken(): String = authRuleToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var authRuleToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(authRuleV2RetrieveParams: AuthRuleV2RetrieveParams) = apply { this.authRuleToken = authRuleV2RetrieveParams.authRuleToken @@ -70,6 +69,11 @@ constructor( fun authRuleToken(authRuleToken: String) = apply { this.authRuleToken = authRuleToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -80,29 +84,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -115,46 +132,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AuthRuleV2RetrieveParams = AuthRuleV2RetrieveParams( checkNotNull(authRuleToken) { "`authRuleToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 9576098d..0b250fb2 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -23,8 +23,8 @@ class AuthRuleV2UpdateParams constructor( private val authRuleToken: String, private val state: State?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -36,9 +36,9 @@ constructor( return AuthRuleV2UpdateBody(state, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -133,9 +133,9 @@ constructor( "AuthRuleV2UpdateBody{state=$state, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -166,8 +166,8 @@ constructor( private var authRuleToken: String? = null private var state: State? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(authRuleV2UpdateParams: AuthRuleV2UpdateParams) = apply { @@ -189,6 +189,11 @@ constructor( */ fun state(state: State) = apply { this.state = state } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -199,29 +204,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -234,33 +252,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -281,14 +305,8 @@ constructor( AuthRuleV2UpdateParams( checkNotNull(authRuleToken) { "`authRuleToken` is required but was not set" }, state, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 cb75f137..a3df2c1c 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 @@ -2,26 +2,25 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class AuthStreamEnrollmentRetrieveSecretParams constructor( - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -48,8 +47,8 @@ constructor( @NoAutoDetect class Builder { - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( authStreamEnrollmentRetrieveSecretParams: AuthStreamEnrollmentRetrieveSecretParams @@ -58,6 +57,11 @@ constructor( additionalQueryParams(authStreamEnrollmentRetrieveSecretParams.additionalQueryParams) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -68,29 +72,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -103,45 +120,45 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): AuthStreamEnrollmentRetrieveSecretParams = AuthStreamEnrollmentRetrieveSecretParams( - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable() + additionalHeaders.build(), + additionalQueryParams.build() ) } } 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 c0c3ba9c..da4e7c57 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 @@ -2,18 +2,18 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects class AuthStreamEnrollmentRotateSecretParams constructor( - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -21,13 +21,13 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -56,8 +56,8 @@ constructor( @NoAutoDetect class Builder { - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -70,6 +70,11 @@ constructor( ) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -80,29 +85,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -115,33 +133,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -160,14 +184,8 @@ constructor( fun build(): AuthStreamEnrollmentRotateSecretParams = AuthStreamEnrollmentRotateSecretParams( - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 72f7b16c..4c5c009d 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -21,8 +20,8 @@ constructor( private val accountToken: String?, private val balanceDate: OffsetDateTime?, private val financialAccountType: FinancialAccountType?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken @@ -31,24 +30,27 @@ constructor( fun financialAccountType(): FinancialAccountType? = financialAccountType - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } this.balanceDate?.let { - params.put("balance_date", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put( + "balance_date", + listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it)) + ) } this.financialAccountType?.let { - params.put("financial_account_type", listOf(it.toString())) + queryParams.put("financial_account_type", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -78,8 +80,8 @@ constructor( private var accountToken: String? = null private var balanceDate: OffsetDateTime? = null private var financialAccountType: FinancialAccountType? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(balanceListParams: BalanceListParams) = apply { this.accountToken = balanceListParams.accountToken @@ -100,6 +102,11 @@ constructor( this.financialAccountType = financialAccountType } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -110,29 +117,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -145,33 +165,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): BalanceListParams = @@ -179,14 +205,8 @@ constructor( accountToken, balanceDate, financialAccountType, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 bf52e288..4578399e 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -29,8 +29,8 @@ constructor( private val type: Type, private val token: String?, private val memo: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -64,9 +64,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = BookTransferCreateBody.Builder::class) @NoAutoDetect @@ -252,9 +252,9 @@ constructor( "BookTransferCreateBody{amount=$amount, category=$category, fromFinancialAccountToken=$fromFinancialAccountToken, subtype=$subtype, toFinancialAccountToken=$toFinancialAccountToken, type=$type, token=$token, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -291,8 +291,8 @@ constructor( private var type: Type? = null private var token: String? = null private var memo: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(bookTransferCreateParams: BookTransferCreateParams) = apply { @@ -349,6 +349,11 @@ constructor( /** Optional descriptor for the transfer. */ fun memo(memo: String) = apply { this.memo = memo } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -359,29 +364,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -394,33 +412,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -451,14 +475,8 @@ constructor( checkNotNull(type) { "`type` is required but was not set" }, token, memo, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 ae67529e..20fce721 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -29,8 +28,8 @@ constructor( private val result: Result?, private val startingAfter: String?, private val status: Status?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken @@ -55,36 +54,36 @@ constructor( fun status(): Status? = status - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.businessAccountToken?.let { - params.put("business_account_token", listOf(it.toString())) + queryParams.put("business_account_token", listOf(it.toString())) } - this.category?.let { params.put("category", listOf(it.toString())) } + this.category?.let { queryParams.put("category", listOf(it.toString())) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } this.financialAccountToken?.let { - params.put("financial_account_token", listOf(it.toString())) - } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.result?.let { params.put("result", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.status?.let { params.put("status", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.put("financial_account_token", listOf(it.toString())) + } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.result?.let { queryParams.put("result", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.status?.let { queryParams.put("status", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -122,8 +121,8 @@ constructor( private var result: Result? = null private var startingAfter: String? = null private var status: Status? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(bookTransferListParams: BookTransferListParams) = apply { this.accountToken = bookTransferListParams.accountToken @@ -191,6 +190,11 @@ constructor( /** Book transfer status to be returned. */ fun status(status: Status) = apply { this.status = status } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -201,29 +205,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -236,33 +253,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): BookTransferListParams = @@ -278,14 +301,8 @@ constructor( result, startingAfter, status, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 d0413c1b..3d1ebe6f 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class BookTransferRetrieveParams constructor( private val bookTransferToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun bookTransferToken(): String = bookTransferToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var bookTransferToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(bookTransferRetrieveParams: BookTransferRetrieveParams) = apply { this.bookTransferToken = bookTransferRetrieveParams.bookTransferToken @@ -72,6 +71,11 @@ constructor( this.bookTransferToken = bookTransferToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -82,29 +86,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -117,33 +134,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): BookTransferRetrieveParams = @@ -151,14 +174,8 @@ constructor( checkNotNull(bookTransferToken) { "`bookTransferToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 7a2f580a..3b6fd6fd 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class BookTransferReverseParams constructor( private val bookTransferToken: String, private val memo: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -32,9 +32,9 @@ constructor( return BookTransferReverseBody(memo, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -117,9 +117,9 @@ constructor( "BookTransferReverseBody{memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -150,8 +150,8 @@ constructor( private var bookTransferToken: String? = null private var memo: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(bookTransferReverseParams: BookTransferReverseParams) = apply { @@ -169,6 +169,11 @@ constructor( /** Optional descriptor for the reversal. */ fun memo(memo: String) = apply { this.memo = memo } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -179,29 +184,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -214,33 +232,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -263,14 +287,8 @@ constructor( "`bookTransferToken` is required but was not set" }, memo, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 e872d32f..b4bc2fee 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -13,29 +12,29 @@ class CardAggregateBalanceListParams constructor( private val accountToken: String?, private val businessAccountToken: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken fun businessAccountToken(): String? = businessAccountToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } this.businessAccountToken?.let { - params.put("business_account_token", listOf(it.toString())) + queryParams.put("business_account_token", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -64,8 +63,8 @@ constructor( private var accountToken: String? = null private var businessAccountToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardAggregateBalanceListParams: CardAggregateBalanceListParams) = apply { this.accountToken = cardAggregateBalanceListParams.accountToken @@ -82,6 +81,11 @@ constructor( this.businessAccountToken = businessAccountToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -92,29 +96,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -127,47 +144,47 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardAggregateBalanceListParams = CardAggregateBalanceListParams( accountToken, businessAccountToken, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 a57df405..3395c7ac 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import java.time.format.DateTimeFormatter @@ -16,8 +15,8 @@ constructor( private val cardToken: String, private val balanceDate: OffsetDateTime?, private val lastTransactionEventToken: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun cardToken(): String = cardToken @@ -26,18 +25,21 @@ constructor( fun lastTransactionEventToken(): String? = lastTransactionEventToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.balanceDate?.let { - params.put("balance_date", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put( + "balance_date", + listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it)) + ) } this.lastTransactionEventToken?.let { - params.put("last_transaction_event_token", listOf(it.toString())) + queryParams.put("last_transaction_event_token", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -47,9 +49,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -79,8 +81,8 @@ constructor( private var cardToken: String? = null private var balanceDate: OffsetDateTime? = null private var lastTransactionEventToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardBalanceListParams: CardBalanceListParams) = apply { this.cardToken = cardBalanceListParams.cardToken @@ -103,6 +105,11 @@ constructor( this.lastTransactionEventToken = lastTransactionEventToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -113,29 +120,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -148,33 +168,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardBalanceListParams = @@ -182,14 +208,8 @@ constructor( checkNotNull(cardToken) { "`cardToken` is required but was not set" }, balanceDate, lastTransactionEventToken, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 35fd3573..372710a4 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -38,8 +38,8 @@ constructor( private val spendLimit: Long?, private val spendLimitDuration: SpendLimitDuration?, private val state: State?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -100,9 +100,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = CardCreateBody.Builder::class) @NoAutoDetect @@ -528,9 +528,9 @@ 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(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -576,8 +576,8 @@ constructor( private var spendLimit: Long? = null private var spendLimitDuration: SpendLimitDuration? = null private var state: State? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardCreateParams: CardCreateParams) = apply { @@ -742,6 +742,11 @@ constructor( */ fun state(state: State) = apply { this.state = state } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -752,29 +757,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -787,33 +805,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -849,14 +873,8 @@ constructor( spendLimit, spendLimitDuration, state, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 248b962e..81cd8d8f 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -13,27 +12,27 @@ class CardEmbedParams constructor( private val embedRequest: String, private val hmac: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun embedRequest(): String = embedRequest fun hmac(): String = hmac - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.embedRequest.let { params.put("embed_request", listOf(it.toString())) } - this.hmac.let { params.put("hmac", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.embedRequest.let { queryParams.put("embed_request", listOf(it.toString())) } + this.hmac.let { queryParams.put("hmac", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -62,8 +61,8 @@ constructor( private var embedRequest: String? = null private var hmac: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardEmbedParams: CardEmbedParams) = apply { this.embedRequest = cardEmbedParams.embedRequest @@ -78,6 +77,11 @@ constructor( /** SHA256 HMAC of the embed_request JSON string with base64 digest. */ fun hmac(hmac: String) = apply { this.hmac = hmac } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -88,29 +92,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -123,47 +140,47 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardEmbedParams = CardEmbedParams( checkNotNull(embedRequest) { "`embedRequest` is required but was not set" }, checkNotNull(hmac) { "`hmac` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 86e968e1..65b1c99f 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -26,8 +25,8 @@ constructor( private val result: Result?, private val startingAfter: String?, private val status: Status?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun cardToken(): String = cardToken @@ -46,23 +45,23 @@ constructor( fun status(): Status? = status - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.category?.let { params.put("category", listOf(it.toString())) } + this.category?.let { queryParams.put("category", listOf(it.toString())) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) - } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.result?.let { params.put("result", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.status?.let { params.put("status", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.result?.let { queryParams.put("result", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.status?.let { queryParams.put("status", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -72,9 +71,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -109,8 +108,8 @@ constructor( private var result: Result? = null private var startingAfter: String? = null private var status: Status? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardFinancialTransactionListParams: CardFinancialTransactionListParams) = apply { @@ -161,6 +160,11 @@ constructor( /** Financial Transaction status to be returned. */ fun status(status: Status) = apply { this.status = status } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -171,29 +175,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -206,33 +223,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardFinancialTransactionListParams = @@ -245,14 +268,8 @@ constructor( result, startingAfter, status, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 03f9692a..40a5ce4f 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -13,17 +12,17 @@ class CardFinancialTransactionRetrieveParams constructor( private val cardToken: String, private val financialTransactionToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun cardToken(): String = cardToken fun financialTransactionToken(): String = financialTransactionToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -33,9 +32,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -64,8 +63,8 @@ constructor( private var cardToken: String? = null private var financialTransactionToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( cardFinancialTransactionRetrieveParams: CardFinancialTransactionRetrieveParams @@ -83,6 +82,11 @@ constructor( this.financialTransactionToken = financialTransactionToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -93,29 +97,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -128,33 +145,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardFinancialTransactionRetrieveParams = @@ -163,14 +186,8 @@ constructor( checkNotNull(financialTransactionToken) { "`financialTransactionToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 75291515..7915b0b2 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -25,8 +24,8 @@ constructor( private val pageSize: Long?, private val startingAfter: String?, private val state: State?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken @@ -43,28 +42,28 @@ constructor( fun state(): State? = state - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.state?.let { params.put("state", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.state?.let { queryParams.put("state", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -98,8 +97,8 @@ constructor( private var pageSize: Long? = null private var startingAfter: String? = null private var state: State? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardListParams: CardListParams) = apply { this.accountToken = cardListParams.accountToken @@ -146,6 +145,11 @@ constructor( /** Returns cards with the specified state. */ fun state(state: State) = apply { this.state = state } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -156,29 +160,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -191,33 +208,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardListParams = @@ -229,14 +252,8 @@ constructor( pageSize, startingAfter, state, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 0257a37c..3c4e2916 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -14,8 +13,8 @@ constructor( private val endingBefore: String?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun endingBefore(): String? = endingBefore @@ -24,20 +23,20 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -67,8 +66,8 @@ constructor( private var endingBefore: String? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardProgramListParams: CardProgramListParams) = apply { this.endingBefore = cardProgramListParams.endingBefore @@ -93,6 +92,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -103,29 +107,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -138,33 +155,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardProgramListParams = @@ -172,14 +195,8 @@ constructor( endingBefore, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 4fac6a2d..404b8236 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class CardProgramRetrieveParams constructor( private val cardProgramToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun cardProgramToken(): String = cardProgramToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var cardProgramToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardProgramRetrieveParams: CardProgramRetrieveParams) = apply { this.cardProgramToken = cardProgramRetrieveParams.cardProgramToken @@ -72,6 +71,11 @@ constructor( this.cardProgramToken = cardProgramToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -82,29 +86,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -117,46 +134,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardProgramRetrieveParams = CardProgramRetrieveParams( checkNotNull(cardProgramToken) { "`cardProgramToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 54201e12..282c9581 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -28,8 +28,8 @@ constructor( private val digitalWallet: DigitalWallet?, private val nonce: String?, private val nonceSignature: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -59,9 +59,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -247,9 +247,9 @@ constructor( "CardProvisionBody{certificate=$certificate, clientDeviceId=$clientDeviceId, clientWalletAccountId=$clientWalletAccountId, digitalWallet=$digitalWallet, nonce=$nonce, nonceSignature=$nonceSignature, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -285,8 +285,8 @@ constructor( private var digitalWallet: DigitalWallet? = null private var nonce: String? = null private var nonceSignature: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardProvisionParams: CardProvisionParams) = apply { @@ -343,6 +343,11 @@ constructor( */ fun nonceSignature(nonceSignature: String) = apply { this.nonceSignature = nonceSignature } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -353,29 +358,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -388,33 +406,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -440,14 +464,8 @@ constructor( digitalWallet, nonce, nonceSignature, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 8d901e48..d6c3af4a 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -26,8 +26,8 @@ constructor( private val productId: String?, private val shippingAddress: ShippingAddress?, private val shippingMethod: ShippingMethod?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -51,9 +51,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -206,9 +206,9 @@ constructor( "CardReissueBody{carrier=$carrier, productId=$productId, shippingAddress=$shippingAddress, shippingMethod=$shippingMethod, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -242,8 +242,8 @@ constructor( private var productId: String? = null private var shippingAddress: ShippingAddress? = null private var shippingMethod: ShippingMethod? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardReissueParams: CardReissueParams) = apply { @@ -289,6 +289,11 @@ constructor( this.shippingMethod = shippingMethod } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -299,29 +304,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -334,33 +352,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -384,14 +408,8 @@ constructor( productId, shippingAddress, shippingMethod, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 6e332302..79f27db3 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -28,8 +28,8 @@ constructor( private val expYear: String?, private val productId: String?, private val shippingMethod: ShippingMethod?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -59,9 +59,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -250,9 +250,9 @@ constructor( "CardRenewBody{shippingAddress=$shippingAddress, carrier=$carrier, expMonth=$expMonth, expYear=$expYear, productId=$productId, shippingMethod=$shippingMethod, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -288,8 +288,8 @@ constructor( private var expYear: String? = null private var productId: String? = null private var shippingMethod: ShippingMethod? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardRenewParams: CardRenewParams) = apply { @@ -349,6 +349,11 @@ constructor( this.shippingMethod = shippingMethod } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -359,29 +364,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -394,33 +412,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -446,14 +470,8 @@ constructor( expYear, productId, shippingMethod, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 7e659374..7c3ed66d 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class CardRetrieveParams constructor( private val cardToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun cardToken(): String = cardToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var cardToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardRetrieveParams: CardRetrieveParams) = apply { this.cardToken = cardRetrieveParams.cardToken @@ -70,6 +69,11 @@ constructor( fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -80,29 +84,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -115,46 +132,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardRetrieveParams = CardRetrieveParams( checkNotNull(cardToken) { "`cardToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 74eb4253..4e0b247f 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class CardRetrieveSpendLimitsParams constructor( private val cardToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun cardToken(): String = cardToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var cardToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(cardRetrieveSpendLimitsParams: CardRetrieveSpendLimitsParams) = apply { this.cardToken = cardRetrieveSpendLimitsParams.cardToken @@ -70,6 +69,11 @@ constructor( fun cardToken(cardToken: String) = apply { this.cardToken = cardToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -80,29 +84,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -115,46 +132,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CardRetrieveSpendLimitsParams = CardRetrieveSpendLimitsParams( checkNotNull(cardToken) { "`cardToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 d6f8280d..c4c2d942 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -18,8 +18,8 @@ import java.util.Objects class CardSearchByPanParams constructor( private val pan: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -29,9 +29,9 @@ constructor( return CardSearchByPanBody(pan, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = CardSearchByPanBody.Builder::class) @NoAutoDetect @@ -110,9 +110,9 @@ constructor( "CardSearchByPanBody{pan=$pan, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -142,8 +142,8 @@ constructor( class Builder { private var pan: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardSearchByPanParams: CardSearchByPanParams) = apply { @@ -156,6 +156,11 @@ constructor( /** The PAN for the card being retrieved. */ fun pan(pan: String) = apply { this.pan = pan } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -166,29 +171,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -201,33 +219,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -247,14 +271,8 @@ constructor( fun build(): CardSearchByPanParams = CardSearchByPanParams( checkNotNull(pan) { "`pan` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 2db58fc1..91b6a879 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -29,8 +29,8 @@ constructor( private val spendLimit: Long?, private val spendLimitDuration: SpendLimitDuration?, private val state: State?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -63,9 +63,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -290,9 +290,9 @@ constructor( "CardUpdateBody{digitalCardArtToken=$digitalCardArtToken, memo=$memo, pin=$pin, pinStatus=$pinStatus, spendLimit=$spendLimit, spendLimitDuration=$spendLimitDuration, state=$state, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -329,8 +329,8 @@ constructor( private var spendLimit: Long? = null private var spendLimitDuration: SpendLimitDuration? = null private var state: State? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(cardUpdateParams: CardUpdateParams) = apply { @@ -407,6 +407,11 @@ constructor( */ fun state(state: State) = apply { this.state = state } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -417,29 +422,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -452,33 +470,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -505,14 +529,8 @@ constructor( spendLimit, spendLimitDuration, state, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 bcfff2e4..efad6075 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 @@ -2,26 +2,25 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class ClientApiStatusParams constructor( - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -48,14 +47,19 @@ constructor( @NoAutoDetect class Builder { - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(clientApiStatusParams: ClientApiStatusParams) = apply { additionalHeaders(clientApiStatusParams.additionalHeaders) additionalQueryParams(clientApiStatusParams.additionalQueryParams) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -66,29 +70,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -101,45 +118,42 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ClientApiStatusParams = - ClientApiStatusParams( - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable() - ) + ClientApiStatusParams(additionalHeaders.build(), additionalQueryParams.build()) } } 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 ccbdb66c..85fb161a 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class CreditProductExtendedCreditRetrieveParams constructor( private val creditProductId: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun creditProductId(): String = creditProductId - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var creditProductId: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( creditProductExtendedCreditRetrieveParams: CreditProductExtendedCreditRetrieveParams @@ -74,6 +73,11 @@ constructor( this.creditProductId = creditProductId } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -84,29 +88,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -119,46 +136,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): CreditProductExtendedCreditRetrieveParams = CreditProductExtendedCreditRetrieveParams( checkNotNull(creditProductId) { "`creditProductId` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 cd10b880..4a3de447 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -14,8 +13,8 @@ constructor( private val endingBefore: String?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun endingBefore(): String? = endingBefore @@ -24,20 +23,20 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -67,8 +66,8 @@ constructor( private var endingBefore: String? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(digitalCardArtListParams: DigitalCardArtListParams) = apply { this.endingBefore = digitalCardArtListParams.endingBefore @@ -93,6 +92,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -103,29 +107,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -138,33 +155,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): DigitalCardArtListParams = @@ -172,14 +195,8 @@ constructor( endingBefore, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 2432bcea..700c14e1 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class DigitalCardArtRetrieveParams constructor( private val digitalCardArtToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun digitalCardArtToken(): String = digitalCardArtToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var digitalCardArtToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(digitalCardArtRetrieveParams: DigitalCardArtRetrieveParams) = apply { this.digitalCardArtToken = digitalCardArtRetrieveParams.digitalCardArtToken @@ -72,6 +71,11 @@ constructor( this.digitalCardArtToken = digitalCardArtToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -82,29 +86,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -117,33 +134,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): DigitalCardArtRetrieveParams = @@ -151,14 +174,8 @@ constructor( checkNotNull(digitalCardArtToken) { "`digitalCardArtToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 5b9b6110..ce017ec9 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -27,8 +27,8 @@ constructor( private val transactionToken: String, private val customerFiledDate: OffsetDateTime?, private val customerNote: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -53,9 +53,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = DisputeCreateBody.Builder::class) @NoAutoDetect @@ -184,9 +184,9 @@ constructor( "DisputeCreateBody{amount=$amount, reason=$reason, transactionToken=$transactionToken, customerFiledDate=$customerFiledDate, customerNote=$customerNote, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -220,8 +220,8 @@ constructor( private var transactionToken: String? = null private var customerFiledDate: OffsetDateTime? = null private var customerNote: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(disputeCreateParams: DisputeCreateParams) = apply { @@ -254,6 +254,11 @@ constructor( /** Customer description of dispute */ fun customerNote(customerNote: String) = apply { this.customerNote = customerNote } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -264,29 +269,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -299,33 +317,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -349,14 +373,8 @@ constructor( checkNotNull(transactionToken) { "`transactionToken` is required but was not set" }, customerFiledDate, customerNote, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 ce8acba2..8e5432d3 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -14,8 +14,8 @@ class DisputeDeleteEvidenceParams constructor( private val disputeToken: String, private val evidenceToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -27,9 +27,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -39,9 +39,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -72,8 +72,8 @@ constructor( private var disputeToken: String? = null private var evidenceToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(disputeDeleteEvidenceParams: DisputeDeleteEvidenceParams) = apply { @@ -88,6 +88,11 @@ constructor( fun evidenceToken(evidenceToken: String) = apply { this.evidenceToken = evidenceToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -98,29 +103,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -133,33 +151,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -180,14 +204,8 @@ constructor( DisputeDeleteEvidenceParams( checkNotNull(disputeToken) { "`disputeToken` is required but was not set" }, checkNotNull(evidenceToken) { "`evidenceToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 70b2f389..545bb23c 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class DisputeDeleteParams constructor( private val disputeToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var disputeToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(disputeDeleteParams: DisputeDeleteParams) = apply { @@ -80,6 +80,11 @@ constructor( fun disputeToken(disputeToken: String) = apply { this.disputeToken = disputeToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -90,29 +95,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -125,33 +143,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -171,14 +195,8 @@ constructor( fun build(): DisputeDeleteParams = DisputeDeleteParams( checkNotNull(disputeToken) { "`disputeToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 f9176bef..bf3f8846 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class DisputeInitiateEvidenceUploadParams constructor( private val disputeToken: String, private val filename: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -32,9 +32,9 @@ constructor( return DisputeInitiateEvidenceUploadBody(filename, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -120,9 +120,9 @@ constructor( "DisputeInitiateEvidenceUploadBody{filename=$filename, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -153,8 +153,8 @@ constructor( private var disputeToken: String? = null private var filename: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -172,6 +172,11 @@ constructor( /** Filename of the evidence. */ fun filename(filename: String) = apply { this.filename = filename } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -182,29 +187,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -217,33 +235,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -264,14 +288,8 @@ constructor( DisputeInitiateEvidenceUploadParams( checkNotNull(disputeToken) { "`disputeToken` is required but was not set" }, filename, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 41c33030..a495ca5d 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import java.time.format.DateTimeFormatter @@ -19,8 +18,8 @@ constructor( private val endingBefore: String?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun disputeToken(): String = disputeToken @@ -35,21 +34,21 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -59,9 +58,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -94,8 +93,8 @@ constructor( private var endingBefore: String? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(disputeListEvidencesParams: DisputeListEvidencesParams) = apply { this.disputeToken = disputeListEvidencesParams.disputeToken @@ -137,6 +136,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -147,29 +151,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -182,33 +199,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): DisputeListEvidencesParams = @@ -219,14 +242,8 @@ constructor( endingBefore, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 af8a03e3..f45565df 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 @@ -3,12 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -25,8 +25,8 @@ constructor( private val startingAfter: String?, private val status: Status?, private val transactionTokens: List?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun begin(): OffsetDateTime? = begin @@ -43,30 +43,30 @@ constructor( fun transactionTokens(): List? = transactionTokens - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.status?.let { params.put("status", listOf(it.toString())) } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.status?.let { queryParams.put("status", listOf(it.toString())) } this.transactionTokens?.let { - params.put("transaction_tokens", listOf(it.joinToString(separator = ","))) + queryParams.put("transaction_tokens", listOf(it.joinToString(separator = ","))) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -100,8 +100,8 @@ constructor( private var startingAfter: String? = null private var status: Status? = null private var transactionTokens: MutableList = mutableListOf() - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(disputeListParams: DisputeListParams) = apply { this.begin = disputeListParams.begin @@ -156,6 +156,11 @@ constructor( this.transactionTokens.add(transactionToken) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -166,29 +171,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -201,33 +219,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): DisputeListParams = @@ -239,14 +263,8 @@ constructor( startingAfter, status, if (transactionTokens.size == 0) null else transactionTokens.toImmutable(), - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 36339d4e..e2e85ea6 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -13,17 +12,17 @@ class DisputeRetrieveEvidenceParams constructor( private val disputeToken: String, private val evidenceToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun disputeToken(): String = disputeToken fun evidenceToken(): String = evidenceToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -33,9 +32,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -64,8 +63,8 @@ constructor( private var disputeToken: String? = null private var evidenceToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(disputeRetrieveEvidenceParams: DisputeRetrieveEvidenceParams) = apply { this.disputeToken = disputeRetrieveEvidenceParams.disputeToken @@ -78,6 +77,11 @@ constructor( fun evidenceToken(evidenceToken: String) = apply { this.evidenceToken = evidenceToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -88,29 +92,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -123,47 +140,47 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): DisputeRetrieveEvidenceParams = DisputeRetrieveEvidenceParams( checkNotNull(disputeToken) { "`disputeToken` is required but was not set" }, checkNotNull(evidenceToken) { "`evidenceToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 a463a411..4aa0c21f 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class DisputeRetrieveParams constructor( private val disputeToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun disputeToken(): String = disputeToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var disputeToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(disputeRetrieveParams: DisputeRetrieveParams) = apply { this.disputeToken = disputeRetrieveParams.disputeToken @@ -70,6 +69,11 @@ constructor( fun disputeToken(disputeToken: String) = apply { this.disputeToken = disputeToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -80,29 +84,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -115,46 +132,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): DisputeRetrieveParams = DisputeRetrieveParams( checkNotNull(disputeToken) { "`disputeToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 29c5d0d3..b081713e 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -27,8 +27,8 @@ constructor( private val customerFiledDate: OffsetDateTime?, private val customerNote: String?, private val reason: Reason?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -52,9 +52,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -175,9 +175,9 @@ constructor( "DisputeUpdateBody{amount=$amount, customerFiledDate=$customerFiledDate, customerNote=$customerNote, reason=$reason, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -211,8 +211,8 @@ constructor( private var customerFiledDate: OffsetDateTime? = null private var customerNote: String? = null private var reason: Reason? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(disputeUpdateParams: DisputeUpdateParams) = apply { @@ -242,6 +242,11 @@ constructor( /** Reason for dispute */ fun reason(reason: Reason) = apply { this.reason = reason } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -252,29 +257,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -287,33 +305,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -337,14 +361,8 @@ constructor( customerFiledDate, customerNote, reason, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 1c9ba7a3..2c038ba8 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -25,8 +24,8 @@ constructor( private val pageSize: Long?, private val startingAfter: String?, private val status: Status?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun eventToken(): String = eventToken @@ -43,22 +42,22 @@ constructor( fun status(): Status? = status - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.status?.let { params.put("status", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.status?.let { queryParams.put("status", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -68,9 +67,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -104,8 +103,8 @@ constructor( private var pageSize: Long? = null private var startingAfter: String? = null private var status: Status? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(eventListAttemptsParams: EventListAttemptsParams) = apply { this.eventToken = eventListAttemptsParams.eventToken @@ -150,6 +149,11 @@ constructor( fun status(status: Status) = apply { this.status = status } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -160,29 +164,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -195,33 +212,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): EventListAttemptsParams = @@ -233,14 +256,8 @@ constructor( pageSize, startingAfter, status, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 abcb205b..bfe82b7a 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 @@ -3,12 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -25,8 +25,8 @@ constructor( private val pageSize: Long?, private val startingAfter: String?, private val withContent: Boolean?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun begin(): OffsetDateTime? = begin @@ -43,28 +43,30 @@ constructor( fun withContent(): Boolean? = withContent - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.eventTypes?.let { params.put("event_types", listOf(it.joinToString(separator = ","))) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.withContent?.let { params.put("with_content", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.eventTypes?.let { + queryParams.put("event_types", listOf(it.joinToString(separator = ","))) + } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.withContent?.let { queryParams.put("with_content", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -98,8 +100,8 @@ constructor( private var pageSize: Long? = null private var startingAfter: String? = null private var withContent: Boolean? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(eventListParams: EventListParams) = apply { this.begin = eventListParams.begin @@ -152,6 +154,11 @@ constructor( /** Whether to include the event payload content in the response. */ fun withContent(withContent: Boolean) = apply { this.withContent = withContent } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -162,29 +169,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -197,33 +217,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): EventListParams = @@ -235,14 +261,8 @@ constructor( pageSize, startingAfter, withContent, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 477bb9ac..b429b370 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class EventRetrieveParams constructor( private val eventToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun eventToken(): String = eventToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var eventToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(eventRetrieveParams: EventRetrieveParams) = apply { this.eventToken = eventRetrieveParams.eventToken @@ -70,6 +69,11 @@ constructor( fun eventToken(eventToken: String) = apply { this.eventToken = eventToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -80,29 +84,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -115,46 +132,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): EventRetrieveParams = EventRetrieveParams( checkNotNull(eventToken) { "`eventToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 d7f974a8..9a466179 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -25,8 +25,8 @@ constructor( private val description: String?, private val disabled: Boolean?, private val eventTypes: List?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -48,9 +48,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = EventSubscriptionCreateBody.Builder::class) @NoAutoDetect @@ -168,9 +168,9 @@ constructor( "EventSubscriptionCreateBody{url=$url, description=$description, disabled=$disabled, eventTypes=$eventTypes, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -203,8 +203,8 @@ constructor( private var description: String? = null private var disabled: Boolean? = null private var eventTypes: MutableList = mutableListOf() - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(eventSubscriptionCreateParams: EventSubscriptionCreateParams) = apply { @@ -241,6 +241,11 @@ constructor( */ fun addEventType(eventType: EventType) = apply { this.eventTypes.add(eventType) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -251,29 +256,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -286,33 +304,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -335,14 +359,8 @@ constructor( description, disabled, if (eventTypes.size == 0) null else eventTypes.toImmutable(), - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 26d7a03b..8ee19797 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class EventSubscriptionDeleteParams constructor( private val eventSubscriptionToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var eventSubscriptionToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(eventSubscriptionDeleteParams: EventSubscriptionDeleteParams) = apply { @@ -82,6 +82,11 @@ constructor( this.eventSubscriptionToken = eventSubscriptionToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -92,29 +97,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -127,33 +145,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -175,14 +199,8 @@ constructor( checkNotNull(eventSubscriptionToken) { "`eventSubscriptionToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 37e2586c..dfc69a66 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -25,8 +24,8 @@ constructor( private val pageSize: Long?, private val startingAfter: String?, private val status: Status?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun eventSubscriptionToken(): String = eventSubscriptionToken @@ -43,22 +42,22 @@ constructor( fun status(): Status? = status - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.status?.let { params.put("status", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.status?.let { queryParams.put("status", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -68,9 +67,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -104,8 +103,8 @@ constructor( private var pageSize: Long? = null private var startingAfter: String? = null private var status: Status? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( eventSubscriptionListAttemptsParams: EventSubscriptionListAttemptsParams @@ -154,6 +153,11 @@ constructor( fun status(status: Status) = apply { this.status = status } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -164,29 +168,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -199,33 +216,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): EventSubscriptionListAttemptsParams = @@ -239,14 +262,8 @@ constructor( pageSize, startingAfter, status, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 5721360d..7e117ad7 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -14,8 +13,8 @@ constructor( private val endingBefore: String?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun endingBefore(): String? = endingBefore @@ -24,20 +23,20 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -67,8 +66,8 @@ constructor( private var endingBefore: String? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(eventSubscriptionListParams: EventSubscriptionListParams) = apply { this.endingBefore = eventSubscriptionListParams.endingBefore @@ -93,6 +92,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -103,29 +107,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -138,33 +155,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): EventSubscriptionListParams = @@ -172,14 +195,8 @@ constructor( endingBefore, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 4d574f02..68bf77f5 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.time.OffsetDateTime @@ -17,8 +17,8 @@ constructor( private val eventSubscriptionToken: String, private val begin: OffsetDateTime?, private val end: OffsetDateTime?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -32,18 +32,18 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -53,9 +53,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -87,8 +87,8 @@ constructor( private var eventSubscriptionToken: String? = null private var begin: OffsetDateTime? = null private var end: OffsetDateTime? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(eventSubscriptionRecoverParams: EventSubscriptionRecoverParams) = apply { @@ -116,6 +116,11 @@ constructor( */ fun end(end: OffsetDateTime) = apply { this.end = end } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -126,29 +131,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -161,33 +179,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -211,14 +235,8 @@ constructor( }, begin, end, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 cc6af580..a5054141 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.time.OffsetDateTime @@ -17,8 +17,8 @@ constructor( private val eventSubscriptionToken: String, private val begin: OffsetDateTime?, private val end: OffsetDateTime?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -32,18 +32,18 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -53,9 +53,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -87,8 +87,8 @@ constructor( private var eventSubscriptionToken: String? = null private var begin: OffsetDateTime? = null private var end: OffsetDateTime? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -119,6 +119,11 @@ constructor( */ fun end(end: OffsetDateTime) = apply { this.end = end } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -129,29 +134,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -164,33 +182,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -214,14 +238,8 @@ constructor( }, begin, end, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 e64bfbca..8d17e9e6 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class EventSubscriptionRetrieveParams constructor( private val eventSubscriptionToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun eventSubscriptionToken(): String = eventSubscriptionToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var eventSubscriptionToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(eventSubscriptionRetrieveParams: EventSubscriptionRetrieveParams) = apply { @@ -73,6 +72,11 @@ constructor( this.eventSubscriptionToken = eventSubscriptionToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -83,29 +87,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -118,33 +135,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): EventSubscriptionRetrieveParams = @@ -152,14 +175,8 @@ constructor( checkNotNull(eventSubscriptionToken) { "`eventSubscriptionToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 ee416b24..12113864 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class EventSubscriptionRetrieveSecretParams constructor( private val eventSubscriptionToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun eventSubscriptionToken(): String = eventSubscriptionToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var eventSubscriptionToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( eventSubscriptionRetrieveSecretParams: EventSubscriptionRetrieveSecretParams @@ -75,6 +74,11 @@ constructor( this.eventSubscriptionToken = eventSubscriptionToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -85,29 +89,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -120,33 +137,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): EventSubscriptionRetrieveSecretParams = @@ -154,14 +177,8 @@ constructor( checkNotNull(eventSubscriptionToken) { "`eventSubscriptionToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 4958af90..20b81499 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class EventSubscriptionRotateSecretParams constructor( private val eventSubscriptionToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var eventSubscriptionToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -84,6 +84,11 @@ constructor( this.eventSubscriptionToken = eventSubscriptionToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -94,29 +99,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -129,33 +147,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -177,14 +201,8 @@ constructor( checkNotNull(eventSubscriptionToken) { "`eventSubscriptionToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 1d037448..b10ec7a0 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -23,8 +23,8 @@ class EventSubscriptionSendSimulatedExampleParams constructor( private val eventSubscriptionToken: String, private val eventType: EventType?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -36,9 +36,9 @@ constructor( return EventSubscriptionSendSimulatedExampleBody(eventType, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -127,9 +127,9 @@ constructor( "EventSubscriptionSendSimulatedExampleBody{eventType=$eventType, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -160,8 +160,8 @@ constructor( private var eventSubscriptionToken: String? = null private var eventType: EventType? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -184,6 +184,11 @@ constructor( /** Event type to send example message for. */ fun eventType(eventType: EventType) = apply { this.eventType = eventType } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -194,29 +199,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -229,33 +247,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -278,14 +302,8 @@ constructor( "`eventSubscriptionToken` is required but was not set" }, eventType, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 e20272c4..e25f062a 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -26,8 +26,8 @@ constructor( private val description: String?, private val disabled: Boolean?, private val eventTypes: List?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -51,9 +51,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -178,9 +178,9 @@ constructor( "EventSubscriptionUpdateBody{url=$url, description=$description, disabled=$disabled, eventTypes=$eventTypes, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -214,8 +214,8 @@ constructor( private var description: String? = null private var disabled: Boolean? = null private var eventTypes: MutableList = mutableListOf() - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(eventSubscriptionUpdateParams: EventSubscriptionUpdateParams) = apply { @@ -257,6 +257,11 @@ constructor( */ fun addEventType(eventType: EventType) = apply { this.eventTypes.add(eventType) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -267,29 +272,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -302,33 +320,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -354,14 +378,8 @@ constructor( description, disabled, if (eventTypes.size == 0) null else eventTypes.toImmutable(), - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 06fa88df..4359656c 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 @@ -13,8 +13,6 @@ import com.fasterxml.jackson.databind.SerializerProvider import com.fasterxml.jackson.databind.annotation.JsonDeserialize import com.fasterxml.jackson.databind.annotation.JsonSerialize import com.fasterxml.jackson.module.kotlin.jacksonTypeRef -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.BaseDeserializer import com.lithic.api.core.BaseSerializer import com.lithic.api.core.Enum @@ -23,6 +21,8 @@ import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect import com.lithic.api.core.getOrThrow +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -35,8 +35,8 @@ constructor( private val plaidCreateBankAccountApiRequest: PlaidCreateBankAccountApiRequest?, private val externallyVerifiedCreateBankAccountApiRequest: ExternallyVerifiedCreateBankAccountApiRequest?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun bankVerifiedCreateBankAccountApiRequest(): BankVerifiedCreateBankAccountApiRequest? = @@ -57,9 +57,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(using = ExternalBankAccountCreateBody.Deserializer::class) @JsonSerialize(using = ExternalBankAccountCreateBody.Serializer::class) @@ -257,9 +257,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -293,8 +293,8 @@ constructor( private var externallyVerifiedCreateBankAccountApiRequest: ExternallyVerifiedCreateBankAccountApiRequest? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(externalBankAccountCreateParams: ExternalBankAccountCreateParams) = apply { @@ -334,6 +334,11 @@ constructor( externallyVerifiedCreateBankAccountApiRequest } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -344,29 +349,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -379,33 +397,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ExternalBankAccountCreateParams = @@ -413,14 +437,8 @@ constructor( bankVerifiedCreateBankAccountApiRequest, plaidCreateBankAccountApiRequest, externallyVerifiedCreateBankAccountApiRequest, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 95e19cb7..c4081c4d 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 @@ -3,12 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -25,8 +25,8 @@ constructor( private val startingAfter: String?, private val states: List?, private val verificationStates: List?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken @@ -47,30 +47,34 @@ constructor( fun verificationStates(): List? = verificationStates - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } this.accountTypes?.let { - params.put("account_types", listOf(it.joinToString(separator = ","))) - } - this.countries?.let { params.put("countries", listOf(it.joinToString(separator = ","))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.ownerTypes?.let { params.put("owner_types", listOf(it.joinToString(separator = ","))) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.states?.let { params.put("states", listOf(it.joinToString(separator = ","))) } + queryParams.put("account_types", listOf(it.joinToString(separator = ","))) + } + this.countries?.let { + queryParams.put("countries", listOf(it.joinToString(separator = ","))) + } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.ownerTypes?.let { + queryParams.put("owner_types", listOf(it.joinToString(separator = ","))) + } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.states?.let { queryParams.put("states", listOf(it.joinToString(separator = ","))) } this.verificationStates?.let { - params.put("verification_states", listOf(it.joinToString(separator = ","))) + queryParams.put("verification_states", listOf(it.joinToString(separator = ","))) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -106,8 +110,8 @@ constructor( private var startingAfter: String? = null private var states: MutableList = mutableListOf() private var verificationStates: MutableList = mutableListOf() - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(externalBankAccountListParams: ExternalBankAccountListParams) = apply { this.accountToken = externalBankAccountListParams.accountToken @@ -177,6 +181,11 @@ constructor( this.verificationStates.add(verificationState) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -187,29 +196,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -222,33 +244,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ExternalBankAccountListParams = @@ -262,14 +290,8 @@ constructor( startingAfter, if (states.size == 0) null else states.toImmutable(), if (verificationStates.size == 0) null else verificationStates.toImmutable(), - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 56560e96..c27d292b 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class ExternalBankAccountMicroDepositCreateParams constructor( private val externalBankAccountToken: String, private val microDeposits: List, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -32,9 +32,9 @@ constructor( return ExternalBankAccountMicroDepositCreateBody(microDeposits, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -124,9 +124,9 @@ constructor( "ExternalBankAccountMicroDepositCreateBody{microDeposits=$microDeposits, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -157,8 +157,8 @@ constructor( private var externalBankAccountToken: String? = null private var microDeposits: MutableList = mutableListOf() - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -185,6 +185,11 @@ constructor( fun addMicroDeposit(microDeposit: Long) = apply { this.microDeposits.add(microDeposit) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -195,29 +200,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -230,33 +248,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -280,14 +304,8 @@ constructor( }, checkNotNull(microDeposits) { "`microDeposits` is required but was not set" } .toImmutable(), - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 a26c3aa5..035a1085 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class ExternalBankAccountRetrieveParams constructor( private val externalBankAccountToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun externalBankAccountToken(): String = externalBankAccountToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var externalBankAccountToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(externalBankAccountRetrieveParams: ExternalBankAccountRetrieveParams) = apply { @@ -74,6 +73,11 @@ constructor( this.externalBankAccountToken = externalBankAccountToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -84,29 +88,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -119,33 +136,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ExternalBankAccountRetrieveParams = @@ -153,14 +176,8 @@ constructor( checkNotNull(externalBankAccountToken) { "`externalBankAccountToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 bbdb1989..f592cea1 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class ExternalBankAccountRetryMicroDepositsParams constructor( private val externalBankAccountToken: String, private val financialAccountToken: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -35,9 +35,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -128,9 +128,9 @@ constructor( "ExternalBankAccountRetryMicroDepositsBody{financialAccountToken=$financialAccountToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -161,8 +161,8 @@ constructor( private var externalBankAccountToken: String? = null private var financialAccountToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -187,6 +187,11 @@ constructor( this.financialAccountToken = financialAccountToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -197,29 +202,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -232,33 +250,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -281,14 +305,8 @@ constructor( "`externalBankAccountToken` is required but was not set" }, financialAccountToken, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 18b6fd0c..30dfb5c3 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class ExternalBankAccountRetryPrenoteParams constructor( private val externalBankAccountToken: String, private val financialAccountToken: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -32,9 +32,9 @@ constructor( return ExternalBankAccountRetryPrenoteBody(financialAccountToken, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -125,9 +125,9 @@ constructor( "ExternalBankAccountRetryPrenoteBody{financialAccountToken=$financialAccountToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -158,8 +158,8 @@ constructor( private var externalBankAccountToken: String? = null private var financialAccountToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -181,6 +181,11 @@ constructor( this.financialAccountToken = financialAccountToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -191,29 +196,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -226,33 +244,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -275,14 +299,8 @@ constructor( "`externalBankAccountToken` is required but was not set" }, financialAccountToken, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 29faab4e..811c331d 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.time.LocalDate @@ -27,8 +27,8 @@ constructor( private val owner: String?, private val ownerType: OwnerType?, private val userDefinedId: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -64,9 +64,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -236,9 +236,9 @@ constructor( "ExternalBankAccountUpdateBody{address=$address, companyId=$companyId, dob=$dob, doingBusinessAs=$doingBusinessAs, name=$name, owner=$owner, ownerType=$ownerType, userDefinedId=$userDefinedId, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -276,8 +276,8 @@ constructor( private var owner: String? = null private var ownerType: OwnerType? = null private var userDefinedId: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalBankAccountUpdateParams: ExternalBankAccountUpdateParams) = @@ -330,6 +330,11 @@ constructor( /** User Defined ID */ fun userDefinedId(userDefinedId: String) = apply { this.userDefinedId = userDefinedId } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -340,29 +345,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -375,33 +393,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -431,14 +455,8 @@ constructor( owner, ownerType, userDefinedId, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 4bf0ac29..c188d9e3 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.time.LocalDate @@ -21,8 +21,8 @@ constructor( private val externalPaymentToken: String, private val effectiveDate: LocalDate, private val memo: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -40,9 +40,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -137,9 +137,9 @@ constructor( "ExternalPaymentCancelBody{effectiveDate=$effectiveDate, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -171,8 +171,8 @@ constructor( private var externalPaymentToken: String? = null private var effectiveDate: LocalDate? = null private var memo: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentCancelParams: ExternalPaymentCancelParams) = apply { @@ -192,6 +192,11 @@ constructor( fun memo(memo: String) = apply { this.memo = memo } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -202,29 +207,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -237,33 +255,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -287,14 +311,8 @@ constructor( }, checkNotNull(effectiveDate) { "`effectiveDate` is required but was not set" }, memo, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 dfb5fefd..21ee4748 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -31,8 +31,8 @@ constructor( private val memo: String?, private val progressTo: ExternalPaymentProgressTo?, private val userDefinedId: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -69,9 +69,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = ExternalPaymentCreateBody.Builder::class) @NoAutoDetect @@ -229,9 +229,9 @@ constructor( "ExternalPaymentCreateBody{amount=$amount, category=$category, effectiveDate=$effectiveDate, financialAccountToken=$financialAccountToken, paymentType=$paymentType, token=$token, memo=$memo, progressTo=$progressTo, userDefinedId=$userDefinedId, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -269,8 +269,8 @@ constructor( private var memo: String? = null private var progressTo: ExternalPaymentProgressTo? = null private var userDefinedId: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentCreateParams: ExternalPaymentCreateParams) = apply { @@ -312,6 +312,11 @@ constructor( fun userDefinedId(userDefinedId: String) = apply { this.userDefinedId = userDefinedId } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -322,29 +327,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -357,33 +375,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -413,14 +437,8 @@ constructor( memo, progressTo, userDefinedId, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 2b1b67c4..fce82493 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -28,8 +27,8 @@ constructor( private val result: TransactionResult?, private val startingAfter: String?, private val status: TransactionStatus?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun begin(): OffsetDateTime? = begin @@ -52,35 +51,35 @@ constructor( fun status(): TransactionStatus? = status - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.businessAccountToken?.let { - params.put("business_account_token", listOf(it.toString())) + queryParams.put("business_account_token", listOf(it.toString())) } - this.category?.let { params.put("category", listOf(it.toString())) } + this.category?.let { queryParams.put("category", listOf(it.toString())) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } this.financialAccountToken?.let { - params.put("financial_account_token", listOf(it.toString())) - } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.result?.let { params.put("result", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.status?.let { params.put("status", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.put("financial_account_token", listOf(it.toString())) + } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.result?.let { queryParams.put("result", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.status?.let { queryParams.put("status", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -117,8 +116,8 @@ constructor( private var result: TransactionResult? = null private var startingAfter: String? = null private var status: TransactionStatus? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(externalPaymentListParams: ExternalPaymentListParams) = apply { this.begin = externalPaymentListParams.begin @@ -183,6 +182,11 @@ constructor( /** Book transfer status to be returned. */ fun status(status: TransactionStatus) = apply { this.status = status } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -193,29 +197,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -228,33 +245,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ExternalPaymentListParams = @@ -269,14 +292,8 @@ constructor( result, startingAfter, status, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 8614043e..5c225127 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.time.LocalDate @@ -21,8 +21,8 @@ constructor( private val externalPaymentToken: String, private val effectiveDate: LocalDate, private val memo: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -40,9 +40,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -137,9 +137,9 @@ constructor( "ExternalPaymentReleaseBody{effectiveDate=$effectiveDate, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -171,8 +171,8 @@ constructor( private var externalPaymentToken: String? = null private var effectiveDate: LocalDate? = null private var memo: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentReleaseParams: ExternalPaymentReleaseParams) = apply { @@ -192,6 +192,11 @@ constructor( fun memo(memo: String) = apply { this.memo = memo } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -202,29 +207,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -237,33 +255,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -287,14 +311,8 @@ constructor( }, checkNotNull(effectiveDate) { "`effectiveDate` is required but was not set" }, memo, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 d492a3a2..15ef7e07 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class ExternalPaymentRetrieveParams constructor( private val externalPaymentToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun externalPaymentToken(): String = externalPaymentToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var externalPaymentToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(externalPaymentRetrieveParams: ExternalPaymentRetrieveParams) = apply { this.externalPaymentToken = externalPaymentRetrieveParams.externalPaymentToken @@ -72,6 +71,11 @@ constructor( this.externalPaymentToken = externalPaymentToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -82,29 +86,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -117,33 +134,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ExternalPaymentRetrieveParams = @@ -151,14 +174,8 @@ constructor( checkNotNull(externalPaymentToken) { "`externalPaymentToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 ab202468..55404e51 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.time.LocalDate @@ -21,8 +21,8 @@ constructor( private val externalPaymentToken: String, private val effectiveDate: LocalDate, private val memo: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -40,9 +40,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -137,9 +137,9 @@ constructor( "ExternalPaymentReverseBody{effectiveDate=$effectiveDate, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -171,8 +171,8 @@ constructor( private var externalPaymentToken: String? = null private var effectiveDate: LocalDate? = null private var memo: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentReverseParams: ExternalPaymentReverseParams) = apply { @@ -192,6 +192,11 @@ constructor( fun memo(memo: String) = apply { this.memo = memo } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -202,29 +207,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -237,33 +255,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -287,14 +311,8 @@ constructor( }, checkNotNull(effectiveDate) { "`effectiveDate` is required but was not set" }, memo, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 8b728c1e..961d8df7 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -26,8 +26,8 @@ constructor( private val effectiveDate: LocalDate, private val memo: String?, private val progressTo: ExternalPaymentProgressTo?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -48,9 +48,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -156,9 +156,9 @@ constructor( "ExternalPaymentSettleBody{effectiveDate=$effectiveDate, memo=$memo, progressTo=$progressTo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -191,8 +191,8 @@ constructor( private var effectiveDate: LocalDate? = null private var memo: String? = null private var progressTo: ExternalPaymentProgressTo? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(externalPaymentSettleParams: ExternalPaymentSettleParams) = apply { @@ -217,6 +217,11 @@ constructor( this.progressTo = progressTo } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -227,29 +232,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -262,33 +280,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -313,14 +337,8 @@ constructor( checkNotNull(effectiveDate) { "`effectiveDate` is required but was not set" }, memo, progressTo, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 0eb7c671..6f68398b 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import java.time.format.DateTimeFormatter @@ -16,8 +15,8 @@ constructor( private val financialAccountToken: String, private val balanceDate: OffsetDateTime?, private val lastTransactionEventToken: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken @@ -26,18 +25,21 @@ constructor( fun lastTransactionEventToken(): String? = lastTransactionEventToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.balanceDate?.let { - params.put("balance_date", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put( + "balance_date", + listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it)) + ) } this.lastTransactionEventToken?.let { - params.put("last_transaction_event_token", listOf(it.toString())) + queryParams.put("last_transaction_event_token", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -47,9 +49,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -79,8 +81,8 @@ constructor( private var financialAccountToken: String? = null private var balanceDate: OffsetDateTime? = null private var lastTransactionEventToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(financialAccountBalanceListParams: FinancialAccountBalanceListParams) = apply { @@ -107,6 +109,11 @@ constructor( this.lastTransactionEventToken = lastTransactionEventToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -117,29 +124,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -152,33 +172,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialAccountBalanceListParams = @@ -188,14 +214,8 @@ constructor( }, balanceDate, lastTransactionEventToken, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 9b8d6e00..c0074249 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -23,8 +23,8 @@ class FinancialAccountChargeOffParams constructor( private val financialAccountToken: String, private val reason: ChargedOffReason, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -36,9 +36,9 @@ constructor( return FinancialAccountChargeOffBody(reason, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -126,9 +126,9 @@ constructor( "FinancialAccountChargeOffBody{reason=$reason, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -159,8 +159,8 @@ constructor( private var financialAccountToken: String? = null private var reason: ChargedOffReason? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(financialAccountChargeOffParams: FinancialAccountChargeOffParams) = @@ -179,6 +179,11 @@ constructor( /** Reason for the financial account being marked as Charged Off */ fun reason(reason: ChargedOffReason) = apply { this.reason = reason } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -189,29 +194,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -224,33 +242,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -273,14 +297,8 @@ constructor( "`financialAccountToken` is required but was not set" }, checkNotNull(reason) { "`reason` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 e6a77cd2..e2ea0e07 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -25,8 +25,8 @@ constructor( private val type: Type, private val accountToken: String?, private val isForBenefitOf: Boolean?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -48,9 +48,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = FinancialAccountCreateBody.Builder::class) @NoAutoDetect @@ -156,9 +156,9 @@ constructor( "FinancialAccountCreateBody{nickname=$nickname, type=$type, accountToken=$accountToken, isForBenefitOf=$isForBenefitOf, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -191,8 +191,8 @@ constructor( private var type: Type? = null private var accountToken: String? = null private var isForBenefitOf: Boolean? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(financialAccountCreateParams: FinancialAccountCreateParams) = apply { @@ -213,6 +213,11 @@ constructor( fun isForBenefitOf(isForBenefitOf: Boolean) = apply { this.isForBenefitOf = isForBenefitOf } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -223,29 +228,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -258,33 +276,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -307,14 +331,8 @@ constructor( checkNotNull(type) { "`type` is required but was not set" }, accountToken, isForBenefitOf, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 b47062ce..5f84e0a3 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class FinancialAccountCreditConfigurationRetrieveParams constructor( private val financialAccountToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var financialAccountToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( financialAccountCreditConfigurationRetrieveParams: @@ -78,6 +77,11 @@ constructor( this.financialAccountToken = financialAccountToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -88,29 +92,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -123,33 +140,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialAccountCreditConfigurationRetrieveParams = @@ -157,14 +180,8 @@ constructor( checkNotNull(financialAccountToken) { "`financialAccountToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 5244bb09..4ae8090c 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -22,8 +22,8 @@ constructor( private val creditProductToken: String?, private val externalBankAccountToken: String?, private val tier: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -47,9 +47,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -176,9 +176,9 @@ constructor( "FinancialAccountCreditConfigurationUpdateBody{creditLimit=$creditLimit, creditProductToken=$creditProductToken, externalBankAccountToken=$externalBankAccountToken, tier=$tier, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -212,8 +212,8 @@ constructor( private var creditProductToken: String? = null private var externalBankAccountToken: String? = null private var tier: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -255,6 +255,11 @@ constructor( /** Tier to assign to a financial account */ fun tier(tier: String) = apply { this.tier = tier } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -265,29 +270,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -300,33 +318,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -352,14 +376,8 @@ constructor( creditProductToken, externalBankAccountToken, tier, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 db1806bb..5a1e4571 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.util.Objects @@ -19,8 +18,8 @@ constructor( private val accountToken: String?, private val businessAccountToken: String?, private val type: Type?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken @@ -29,22 +28,22 @@ constructor( fun type(): Type? = type - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } this.businessAccountToken?.let { - params.put("business_account_token", listOf(it.toString())) + queryParams.put("business_account_token", listOf(it.toString())) } - this.type?.let { params.put("type", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.type?.let { queryParams.put("type", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -74,8 +73,8 @@ constructor( private var accountToken: String? = null private var businessAccountToken: String? = null private var type: Type? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(financialAccountListParams: FinancialAccountListParams) = apply { this.accountToken = financialAccountListParams.accountToken @@ -96,6 +95,11 @@ constructor( /** List financial accounts of a given type */ fun type(type: Type) = apply { this.type = type } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -106,29 +110,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -141,33 +158,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialAccountListParams = @@ -175,14 +198,8 @@ constructor( accountToken, businessAccountToken, type, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 5eb9741f..ae80b315 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.LocalDate import java.util.Objects @@ -18,8 +17,8 @@ constructor( private val endingBefore: String?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken @@ -34,17 +33,17 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders - - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.begin?.let { params.put("begin", listOf(it.toString())) } - this.end?.let { params.put("end", listOf(it.toString())) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getHeaders(): Headers = additionalHeaders + + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.begin?.let { queryParams.put("begin", listOf(it.toString())) } + this.end?.let { queryParams.put("end", listOf(it.toString())) } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -54,9 +53,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -89,8 +88,8 @@ constructor( private var endingBefore: String? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(financialAccountLoanTapeListParams: FinancialAccountLoanTapeListParams) = apply { @@ -137,6 +136,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -147,29 +151,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -182,33 +199,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialAccountLoanTapeListParams = @@ -221,14 +244,8 @@ constructor( endingBefore, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 3fd3c6fa..629cea76 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -13,17 +12,17 @@ class FinancialAccountLoanTapeRetrieveParams constructor( private val financialAccountToken: String, private val loanTapeToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken fun loanTapeToken(): String = loanTapeToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -33,9 +32,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -64,8 +63,8 @@ constructor( private var financialAccountToken: String? = null private var loanTapeToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( financialAccountLoanTapeRetrieveParams: FinancialAccountLoanTapeRetrieveParams @@ -85,6 +84,11 @@ constructor( /** Globally unique identifier for loan tape. */ fun loanTapeToken(loanTapeToken: String) = apply { this.loanTapeToken = loanTapeToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -95,29 +99,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -130,33 +147,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialAccountLoanTapeRetrieveParams = @@ -165,14 +188,8 @@ constructor( "`financialAccountToken` is required but was not set" }, checkNotNull(loanTapeToken) { "`loanTapeToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 6f5da9db..a3038c74 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class FinancialAccountRetrieveParams constructor( private val financialAccountToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var financialAccountToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(financialAccountRetrieveParams: FinancialAccountRetrieveParams) = apply { this.financialAccountToken = financialAccountRetrieveParams.financialAccountToken @@ -72,6 +71,11 @@ constructor( this.financialAccountToken = financialAccountToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -82,29 +86,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -117,33 +134,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialAccountRetrieveParams = @@ -151,14 +174,8 @@ constructor( checkNotNull(financialAccountToken) { "`financialAccountToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 6d3d2d3b..d025f8e0 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -16,8 +15,8 @@ constructor( private val endingBefore: String?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken @@ -30,15 +29,15 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -49,9 +48,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -83,8 +82,8 @@ constructor( private var endingBefore: String? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( financialAccountStatementLineItemListParams: FinancialAccountStatementLineItemListParams @@ -122,6 +121,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -132,29 +136,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -167,33 +184,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialAccountStatementLineItemListParams = @@ -205,14 +228,8 @@ constructor( endingBefore, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 bdf22f6c..77fb492c 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.LocalDate import java.util.Objects @@ -19,8 +18,8 @@ constructor( private val includeInitialStatements: Boolean?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken @@ -37,20 +36,20 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.begin?.let { params.put("begin", listOf(it.toString())) } - this.end?.let { params.put("end", listOf(it.toString())) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.begin?.let { queryParams.put("begin", listOf(it.toString())) } + this.end?.let { queryParams.put("end", listOf(it.toString())) } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } this.includeInitialStatements?.let { - params.put("include_initial_statements", listOf(it.toString())) + queryParams.put("include_initial_statements", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -60,9 +59,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -96,8 +95,8 @@ constructor( private var includeInitialStatements: Boolean? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( financialAccountStatementListParams: FinancialAccountStatementListParams @@ -151,6 +150,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -161,29 +165,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -196,33 +213,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialAccountStatementListParams = @@ -236,14 +259,8 @@ constructor( includeInitialStatements, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 fa4cd6cc..4fe6ebd8 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -13,17 +12,17 @@ class FinancialAccountStatementRetrieveParams constructor( private val financialAccountToken: String, private val statementToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken fun statementToken(): String = statementToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -33,9 +32,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -64,8 +63,8 @@ constructor( private var financialAccountToken: String? = null private var statementToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( financialAccountStatementRetrieveParams: FinancialAccountStatementRetrieveParams @@ -85,6 +84,11 @@ constructor( /** Globally unique identifier for statements. */ fun statementToken(statementToken: String) = apply { this.statementToken = statementToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -95,29 +99,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -130,33 +147,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialAccountStatementRetrieveParams = @@ -165,14 +188,8 @@ constructor( "`financialAccountToken` is required but was not set" }, checkNotNull(statementToken) { "`statementToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 7dcffc25..b1ed1397 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class FinancialAccountUpdateParams constructor( private val financialAccountToken: String, private val nickname: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -32,9 +32,9 @@ constructor( return FinancialAccountUpdateBody(nickname, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -116,9 +116,9 @@ constructor( "FinancialAccountUpdateBody{nickname=$nickname, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -149,8 +149,8 @@ constructor( private var financialAccountToken: String? = null private var nickname: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(financialAccountUpdateParams: FinancialAccountUpdateParams) = apply { @@ -167,6 +167,11 @@ constructor( fun nickname(nickname: String) = apply { this.nickname = nickname } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -177,29 +182,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -212,33 +230,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -261,14 +285,8 @@ constructor( "`financialAccountToken` is required but was not set" }, nickname, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 e1fd77e2..bf338b39 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -26,8 +25,8 @@ constructor( private val result: Result?, private val startingAfter: String?, private val status: Status?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken @@ -46,23 +45,23 @@ constructor( fun status(): Status? = status - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.category?.let { params.put("category", listOf(it.toString())) } + this.category?.let { queryParams.put("category", listOf(it.toString())) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) - } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.result?.let { params.put("result", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.status?.let { params.put("status", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.result?.let { queryParams.put("result", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.status?.let { queryParams.put("status", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -72,9 +71,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -109,8 +108,8 @@ constructor( private var result: Result? = null private var startingAfter: String? = null private var status: Status? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(financialTransactionListParams: FinancialTransactionListParams) = apply { this.financialAccountToken = financialTransactionListParams.financialAccountToken @@ -162,6 +161,11 @@ constructor( /** Financial Transaction status to be returned. */ fun status(status: Status) = apply { this.status = status } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -172,29 +176,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -207,33 +224,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialTransactionListParams = @@ -248,14 +271,8 @@ constructor( result, startingAfter, status, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 652f480a..9c5e9439 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects @@ -13,17 +12,17 @@ class FinancialTransactionRetrieveParams constructor( private val financialAccountToken: String, private val financialTransactionToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun financialAccountToken(): String = financialAccountToken fun financialTransactionToken(): String = financialTransactionToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -33,9 +32,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -64,8 +63,8 @@ constructor( private var financialAccountToken: String? = null private var financialTransactionToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(financialTransactionRetrieveParams: FinancialTransactionRetrieveParams) = apply { @@ -85,6 +84,11 @@ constructor( this.financialTransactionToken = financialTransactionToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -95,29 +99,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -130,33 +147,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): FinancialTransactionRetrieveParams = @@ -167,14 +190,8 @@ constructor( checkNotNull(financialTransactionToken) { "`financialTransactionToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 514ad235..87ce28c7 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -32,8 +32,8 @@ constructor( private val memo: String?, private val subtype: String?, private val userDefinedId: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -73,9 +73,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = ManagementOperationCreateBody.Builder::class) @NoAutoDetect @@ -242,9 +242,9 @@ 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(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -283,8 +283,8 @@ constructor( private var memo: String? = null private var subtype: String? = null private var userDefinedId: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(managementOperationCreateParams: ManagementOperationCreateParams) = @@ -330,6 +330,11 @@ constructor( fun userDefinedId(userDefinedId: String) = apply { this.userDefinedId = userDefinedId } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -340,29 +345,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -375,33 +393,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -432,14 +456,8 @@ constructor( memo, subtype, userDefinedId, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 3fcaa411..0999db67 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -27,8 +26,8 @@ constructor( private val pageSize: Long?, private val startingAfter: String?, private val status: TransactionStatus?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun begin(): OffsetDateTime? = begin @@ -49,34 +48,34 @@ constructor( fun status(): TransactionStatus? = status - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.businessAccountToken?.let { - params.put("business_account_token", listOf(it.toString())) + queryParams.put("business_account_token", listOf(it.toString())) } - this.category?.let { params.put("category", listOf(it.toString())) } + this.category?.let { queryParams.put("category", listOf(it.toString())) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } this.financialAccountToken?.let { - params.put("financial_account_token", listOf(it.toString())) + queryParams.put("financial_account_token", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.status?.let { params.put("status", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.status?.let { queryParams.put("status", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -112,8 +111,8 @@ constructor( private var pageSize: Long? = null private var startingAfter: String? = null private var status: TransactionStatus? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(managementOperationListParams: ManagementOperationListParams) = apply { this.begin = managementOperationListParams.begin @@ -174,6 +173,11 @@ constructor( /** Management operation status to be returned. */ fun status(status: TransactionStatus) = apply { this.status = status } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -184,29 +188,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -219,33 +236,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ManagementOperationListParams = @@ -259,14 +282,8 @@ constructor( pageSize, startingAfter, status, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 6f790864..4a3177db 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class ManagementOperationRetrieveParams constructor( private val managementOperationToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun managementOperationToken(): String = managementOperationToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var managementOperationToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(managementOperationRetrieveParams: ManagementOperationRetrieveParams) = apply { @@ -74,6 +73,11 @@ constructor( this.managementOperationToken = managementOperationToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -84,29 +88,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -119,33 +136,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ManagementOperationRetrieveParams = @@ -153,14 +176,8 @@ constructor( checkNotNull(managementOperationToken) { "`managementOperationToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 88e06bed..6830a86e 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.time.LocalDate @@ -21,8 +21,8 @@ constructor( private val managementOperationToken: String, private val effectiveDate: LocalDate, private val memo: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -40,9 +40,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -138,9 +138,9 @@ constructor( "ManagementOperationReverseBody{effectiveDate=$effectiveDate, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -172,8 +172,8 @@ constructor( private var managementOperationToken: String? = null private var effectiveDate: LocalDate? = null private var memo: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(managementOperationReverseParams: ManagementOperationReverseParams) = @@ -195,6 +195,11 @@ constructor( fun memo(memo: String) = apply { this.memo = memo } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -205,29 +210,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -240,33 +258,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -290,14 +314,8 @@ constructor( }, checkNotNull(effectiveDate) { "`effectiveDate` is required but was not set" }, memo, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 ff5a44ba..9abed6d4 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -30,8 +30,8 @@ constructor( private val token: String?, private val memo: String?, private val userDefinedId: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -68,9 +68,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = PaymentCreateBody.Builder::class) @NoAutoDetect @@ -238,9 +238,9 @@ constructor( "PaymentCreateBody{amount=$amount, externalBankAccountToken=$externalBankAccountToken, financialAccountToken=$financialAccountToken, method=$method, methodAttributes=$methodAttributes, type=$type, token=$token, memo=$memo, userDefinedId=$userDefinedId, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -278,8 +278,8 @@ constructor( private var token: String? = null private var memo: String? = null private var userDefinedId: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentCreateParams: PaymentCreateParams) = apply { @@ -325,6 +325,11 @@ constructor( fun userDefinedId(userDefinedId: String) = apply { this.userDefinedId = userDefinedId } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -335,29 +340,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -370,33 +388,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -428,14 +452,8 @@ constructor( token, memo, userDefinedId, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 7f68dc55..f2e76a59 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -29,8 +28,8 @@ constructor( private val result: Result?, private val startingAfter: String?, private val status: Status?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken @@ -55,36 +54,36 @@ constructor( fun status(): Status? = status - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } this.businessAccountToken?.let { - params.put("business_account_token", listOf(it.toString())) + queryParams.put("business_account_token", listOf(it.toString())) } - this.category?.let { params.put("category", listOf(it.toString())) } + this.category?.let { queryParams.put("category", listOf(it.toString())) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } this.financialAccountToken?.let { - params.put("financial_account_token", listOf(it.toString())) - } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.result?.let { params.put("result", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.status?.let { params.put("status", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + queryParams.put("financial_account_token", listOf(it.toString())) + } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.result?.let { queryParams.put("result", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.status?.let { queryParams.put("status", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -122,8 +121,8 @@ constructor( private var result: Result? = null private var startingAfter: String? = null private var status: Status? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(paymentListParams: PaymentListParams) = apply { this.accountToken = paymentListParams.accountToken @@ -184,6 +183,11 @@ constructor( fun status(status: Status) = apply { this.status = status } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -194,29 +198,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -229,33 +246,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): PaymentListParams = @@ -271,14 +294,8 @@ constructor( result, startingAfter, status, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 5ff456dd..28badaa7 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class PaymentRetrieveParams constructor( private val paymentToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun paymentToken(): String = paymentToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var paymentToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(paymentRetrieveParams: PaymentRetrieveParams) = apply { this.paymentToken = paymentRetrieveParams.paymentToken @@ -70,6 +69,11 @@ constructor( fun paymentToken(paymentToken: String) = apply { this.paymentToken = paymentToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -80,29 +84,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -115,46 +132,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): PaymentRetrieveParams = PaymentRetrieveParams( checkNotNull(paymentToken) { "`paymentToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 67f6ea60..ea4b743a 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class PaymentRetryParams constructor( private val paymentToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var paymentToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentRetryParams: PaymentRetryParams) = apply { @@ -80,6 +80,11 @@ constructor( fun paymentToken(paymentToken: String) = apply { this.paymentToken = paymentToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -90,29 +95,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -125,33 +143,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -171,14 +195,8 @@ constructor( fun build(): PaymentRetryParams = PaymentRetryParams( checkNotNull(paymentToken) { "`paymentToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 343f6fb5..376e950f 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -25,8 +25,8 @@ constructor( private val eventType: SupportedSimulationTypes, private val declineReason: SupportedSimulationDeclineReasons?, private val returnReasonCode: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -47,9 +47,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -165,9 +165,9 @@ constructor( "PaymentSimulateActionBody{eventType=$eventType, declineReason=$declineReason, returnReasonCode=$returnReasonCode, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -200,8 +200,8 @@ constructor( private var eventType: SupportedSimulationTypes? = null private var declineReason: SupportedSimulationDeclineReasons? = null private var returnReasonCode: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentSimulateActionParams: PaymentSimulateActionParams) = apply { @@ -229,6 +229,11 @@ constructor( this.returnReasonCode = returnReasonCode } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -239,29 +244,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -274,33 +292,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -323,14 +347,8 @@ constructor( checkNotNull(eventType) { "`eventType` is required but was not set" }, declineReason, returnReasonCode, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 b8cef7de..bc020581 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -26,8 +26,8 @@ constructor( private val financialAccountToken: String, private val receiptType: ReceiptType, private val memo: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -52,9 +52,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = PaymentSimulateReceiptBody.Builder::class) @NoAutoDetect @@ -180,9 +180,9 @@ constructor( "PaymentSimulateReceiptBody{token=$token, amount=$amount, financialAccountToken=$financialAccountToken, receiptType=$receiptType, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -216,8 +216,8 @@ constructor( private var financialAccountToken: String? = null private var receiptType: ReceiptType? = null private var memo: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentSimulateReceiptParams: PaymentSimulateReceiptParams) = apply { @@ -248,6 +248,11 @@ constructor( /** Memo */ fun memo(memo: String) = apply { this.memo = memo } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -258,29 +263,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -293,33 +311,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -345,14 +369,8 @@ constructor( }, checkNotNull(receiptType) { "`receiptType` is required but was not set" }, memo, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 f4c080e9..ab711272 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -18,8 +18,8 @@ import java.util.Objects class PaymentSimulateReleaseParams constructor( private val paymentToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -29,9 +29,9 @@ constructor( return PaymentSimulateReleaseBody(paymentToken, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = PaymentSimulateReleaseBody.Builder::class) @NoAutoDetect @@ -111,9 +111,9 @@ constructor( "PaymentSimulateReleaseBody{paymentToken=$paymentToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -143,8 +143,8 @@ constructor( class Builder { private var paymentToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentSimulateReleaseParams: PaymentSimulateReleaseParams) = apply { @@ -157,6 +157,11 @@ constructor( /** Payment Token */ fun paymentToken(paymentToken: String) = apply { this.paymentToken = paymentToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -167,29 +172,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -202,33 +220,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -248,14 +272,8 @@ constructor( fun build(): PaymentSimulateReleaseParams = PaymentSimulateReleaseParams( checkNotNull(paymentToken) { "`paymentToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 2ceb2eab..8f4543e5 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class PaymentSimulateReturnParams constructor( private val paymentToken: String, private val returnReasonCode: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -36,9 +36,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = PaymentSimulateReturnBody.Builder::class) @NoAutoDetect @@ -131,9 +131,9 @@ constructor( "PaymentSimulateReturnBody{paymentToken=$paymentToken, returnReasonCode=$returnReasonCode, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -164,8 +164,8 @@ constructor( private var paymentToken: String? = null private var returnReasonCode: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(paymentSimulateReturnParams: PaymentSimulateReturnParams) = apply { @@ -184,6 +184,11 @@ constructor( this.returnReasonCode = returnReasonCode } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -194,29 +199,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -229,33 +247,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -276,14 +300,8 @@ constructor( PaymentSimulateReturnParams( checkNotNull(paymentToken) { "`paymentToken` is required but was not set" }, returnReasonCode, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 5488ea83..b3238bb6 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.LocalDate import java.util.Objects @@ -16,8 +15,8 @@ constructor( private val endingBefore: String?, private val pageSize: Long?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun reportDate(): LocalDate = reportDate @@ -28,15 +27,15 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } fun getPathParam(index: Int): String { @@ -46,9 +45,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -79,8 +78,8 @@ constructor( private var endingBefore: String? = null private var pageSize: Long? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(reportSettlementListDetailsParams: ReportSettlementListDetailsParams) = apply { @@ -109,6 +108,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -119,29 +123,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -154,33 +171,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ReportSettlementListDetailsParams = @@ -189,14 +212,8 @@ constructor( endingBefore, pageSize, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 93dc36da..dffcca2d 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 @@ -2,10 +2,9 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.LocalDate import java.util.Objects @@ -13,15 +12,15 @@ import java.util.Objects class ReportSettlementSummaryParams constructor( private val reportDate: LocalDate, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun reportDate(): LocalDate = reportDate - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -30,9 +29,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -60,8 +59,8 @@ constructor( class Builder { private var reportDate: LocalDate? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(reportSettlementSummaryParams: ReportSettlementSummaryParams) = apply { this.reportDate = reportSettlementSummaryParams.reportDate @@ -71,6 +70,11 @@ constructor( fun reportDate(reportDate: LocalDate) = apply { this.reportDate = reportDate } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -81,29 +85,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -116,46 +133,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ReportSettlementSummaryParams = ReportSettlementSummaryParams( checkNotNull(reportDate) { "`reportDate` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 6c6a6ceb..154ebd1b 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.util.Objects @@ -17,24 +16,24 @@ import java.util.Objects class ResponderEndpointCheckStatusParams constructor( private val type: Type, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun type(): Type = type - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.type.let { params.put("type", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.type.let { queryParams.put("type", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -62,8 +61,8 @@ constructor( class Builder { private var type: Type? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(responderEndpointCheckStatusParams: ResponderEndpointCheckStatusParams) = apply { @@ -75,6 +74,11 @@ constructor( /** The type of the endpoint. */ fun type(type: Type) = apply { this.type = type } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -85,29 +89,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -120,46 +137,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ResponderEndpointCheckStatusParams = ResponderEndpointCheckStatusParams( checkNotNull(type) { "`type` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 d474ef0d..f5316e30 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -23,8 +23,8 @@ class ResponderEndpointCreateParams constructor( private val type: Type?, private val url: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -40,9 +40,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = ResponderEndpointCreateBody.Builder::class) @NoAutoDetect @@ -131,9 +131,9 @@ constructor( "ResponderEndpointCreateBody{type=$type, url=$url, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -164,8 +164,8 @@ constructor( private var type: Type? = null private var url: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(responderEndpointCreateParams: ResponderEndpointCreateParams) = apply { @@ -182,6 +182,11 @@ constructor( /** The URL for the responder endpoint (must be http(s)). */ fun url(url: String) = apply { this.url = url } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -192,29 +197,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -227,33 +245,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -274,14 +298,8 @@ constructor( ResponderEndpointCreateParams( type, url, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 27ba809d..7c0e98f6 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 @@ -3,12 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -17,8 +17,8 @@ import java.util.Objects class ResponderEndpointDeleteParams constructor( private val type: Type, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -28,18 +28,18 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.type.let { params.put("type", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.type.let { queryParams.put("type", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -69,8 +69,8 @@ constructor( class Builder { private var type: Type? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(responderEndpointDeleteParams: ResponderEndpointDeleteParams) = apply { @@ -83,6 +83,11 @@ constructor( /** The type of the endpoint. */ fun type(type: Type) = apply { this.type = type } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -93,29 +98,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -128,33 +146,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -174,14 +198,8 @@ constructor( fun build(): ResponderEndpointDeleteParams = ResponderEndpointDeleteParams( checkNotNull(type) { "`type` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 bd5cdaf8..d6fc8a07 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class ThreeDSAuthenticationRetrieveParams constructor( private val threeDSAuthenticationToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun threeDSAuthenticationToken(): String = threeDSAuthenticationToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var threeDSAuthenticationToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( threeDSAuthenticationRetrieveParams: ThreeDSAuthenticationRetrieveParams @@ -75,6 +74,11 @@ constructor( this.threeDSAuthenticationToken = threeDSAuthenticationToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -85,29 +89,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -120,33 +137,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ThreeDSAuthenticationRetrieveParams = @@ -154,14 +177,8 @@ constructor( checkNotNull(threeDSAuthenticationToken) { "`threeDSAuthenticationToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 ad983436..1dd90011 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -25,8 +25,8 @@ constructor( private val pan: String, private val transaction: Transaction, private val cardExpiryCheck: CardExpiryCheck?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -48,9 +48,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = ThreeDSAuthenticationSimulateBody.Builder::class) @NoAutoDetect @@ -168,9 +168,9 @@ constructor( "ThreeDSAuthenticationSimulateBody{merchant=$merchant, pan=$pan, transaction=$transaction, cardExpiryCheck=$cardExpiryCheck, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -203,8 +203,8 @@ constructor( private var pan: String? = null private var transaction: Transaction? = null private var cardExpiryCheck: CardExpiryCheck? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -234,6 +234,11 @@ constructor( this.cardExpiryCheck = cardExpiryCheck } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -244,29 +249,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -279,33 +297,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -328,14 +352,8 @@ constructor( checkNotNull(pan) { "`pan` is required but was not set" }, checkNotNull(transaction) { "`transaction` is required but was not set" }, cardExpiryCheck, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 bbf53d9c..b5b6dfbe 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class ThreeDSDecisioningChallengeResponseParams constructor( private val token: String, private val challengeResponse: ChallengeResult, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -36,9 +36,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = ThreeDSDecisioningChallengeResponseBody.Builder::class) @NoAutoDetect @@ -143,9 +143,9 @@ constructor( "ThreeDSDecisioningChallengeResponseBody{token=$token, challengeResponse=$challengeResponse, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -176,8 +176,8 @@ constructor( private var token: String? = null private var challengeResponse: ChallengeResult? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -204,6 +204,11 @@ constructor( this.challengeResponse = challengeResponse } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -214,29 +219,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -249,33 +267,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -298,14 +322,8 @@ constructor( checkNotNull(challengeResponse) { "`challengeResponse` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 2d3b20be..e90597e9 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 @@ -2,26 +2,25 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class ThreeDSDecisioningRetrieveSecretParams constructor( - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -48,8 +47,8 @@ constructor( @NoAutoDetect class Builder { - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( threeDSDecisioningRetrieveSecretParams: ThreeDSDecisioningRetrieveSecretParams @@ -58,6 +57,11 @@ constructor( additionalQueryParams(threeDSDecisioningRetrieveSecretParams.additionalQueryParams) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -68,29 +72,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -103,45 +120,45 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): ThreeDSDecisioningRetrieveSecretParams = ThreeDSDecisioningRetrieveSecretParams( - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable() + additionalHeaders.build(), + additionalQueryParams.build() ) } } 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 5456e508..65ce02e2 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 @@ -2,18 +2,18 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects class ThreeDSDecisioningRotateSecretParams constructor( - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -21,13 +21,13 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -56,8 +56,8 @@ constructor( @NoAutoDetect class Builder { - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -68,6 +68,11 @@ constructor( additionalBodyProperties(threeDSDecisioningRotateSecretParams.additionalBodyProperties) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -78,29 +83,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -113,33 +131,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -158,14 +182,8 @@ constructor( fun build(): ThreeDSDecisioningRotateSecretParams = ThreeDSDecisioningRotateSecretParams( - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 1f90d01b..009820c7 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -18,8 +18,8 @@ import java.util.Objects class ThreeDSDecisioningSimulateChallengeParams constructor( private val token: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -29,9 +29,9 @@ constructor( return ThreeDSDecisioningSimulateChallengeBody(token, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = ThreeDSDecisioningSimulateChallengeBody.Builder::class) @NoAutoDetect @@ -115,9 +115,9 @@ constructor( "ThreeDSDecisioningSimulateChallengeBody{token=$token, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -147,8 +147,8 @@ constructor( class Builder { private var token: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -168,6 +168,11 @@ constructor( */ fun token(token: String) = apply { this.token = token } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -178,29 +183,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -213,33 +231,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -259,14 +283,8 @@ constructor( fun build(): ThreeDSDecisioningSimulateChallengeParams = ThreeDSDecisioningSimulateChallengeParams( token, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 49dc784e..15ba5c34 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class ThreeDSDecisioningSimulateChallengeResponseParams constructor( private val token: String, private val challengeResponse: ChallengeResult, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -36,9 +36,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = ThreeDSDecisioningSimulateChallengeResponseBody.Builder::class) @NoAutoDetect @@ -147,9 +147,9 @@ constructor( "ThreeDSDecisioningSimulateChallengeResponseBody{token=$token, challengeResponse=$challengeResponse, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -180,8 +180,8 @@ constructor( private var token: String? = null private var challengeResponse: ChallengeResult? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -212,6 +212,11 @@ constructor( this.challengeResponse = challengeResponse } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -222,29 +227,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -257,33 +275,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -306,14 +330,8 @@ constructor( checkNotNull(challengeResponse) { "`challengeResponse` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 4d512f67..f7d6a337 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class TokenizationActivateParams constructor( private val tokenizationToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var tokenizationToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationActivateParams: TokenizationActivateParams) = apply { @@ -82,6 +82,11 @@ constructor( this.tokenizationToken = tokenizationToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -92,29 +97,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -127,33 +145,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -175,14 +199,8 @@ constructor( checkNotNull(tokenizationToken) { "`tokenizationToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 c1fc192f..b1911222 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class TokenizationDeactivateParams constructor( private val tokenizationToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var tokenizationToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationDeactivateParams: TokenizationDeactivateParams) = apply { @@ -82,6 +82,11 @@ constructor( this.tokenizationToken = tokenizationToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -92,29 +97,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -127,33 +145,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -175,14 +199,8 @@ constructor( checkNotNull(tokenizationToken) { "`tokenizationToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 459a4a5e..7517bb75 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 @@ -2,26 +2,25 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class TokenizationDecisioningRetrieveSecretParams constructor( - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -48,8 +47,8 @@ constructor( @NoAutoDetect class Builder { - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( tokenizationDecisioningRetrieveSecretParams: TokenizationDecisioningRetrieveSecretParams @@ -58,6 +57,11 @@ constructor( additionalQueryParams(tokenizationDecisioningRetrieveSecretParams.additionalQueryParams) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -68,29 +72,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -103,45 +120,45 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): TokenizationDecisioningRetrieveSecretParams = TokenizationDecisioningRetrieveSecretParams( - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable() + additionalHeaders.build(), + additionalQueryParams.build() ) } } 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 a612a18a..9609c9c1 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 @@ -2,18 +2,18 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects class TokenizationDecisioningRotateSecretParams constructor( - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -21,13 +21,13 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -56,8 +56,8 @@ constructor( @NoAutoDetect class Builder { - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -70,6 +70,11 @@ constructor( ) } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -80,29 +85,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -115,33 +133,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -160,14 +184,8 @@ constructor( fun build(): TokenizationDecisioningRotateSecretParams = TokenizationDecisioningRotateSecretParams( - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 e02d885a..62885180 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.LocalDate @@ -25,8 +24,8 @@ constructor( private val pageSize: Long?, private val startingAfter: String?, private val tokenizationChannel: TokenizationChannel?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken @@ -45,25 +44,27 @@ constructor( fun tokenizationChannel(): TokenizationChannel? = tokenizationChannel - internal fun getHeaders(): Map> = additionalHeaders - - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } - this.begin?.let { params.put("begin", listOf(it.toString())) } - this.cardToken?.let { params.put("card_token", listOf(it.toString())) } - this.end?.let { params.put("end", listOf(it.toString())) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - this.tokenizationChannel?.let { params.put("tokenization_channel", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + internal fun getHeaders(): Headers = additionalHeaders + + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } + this.begin?.let { queryParams.put("begin", listOf(it.toString())) } + this.cardToken?.let { queryParams.put("card_token", listOf(it.toString())) } + this.end?.let { queryParams.put("end", listOf(it.toString())) } + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + this.tokenizationChannel?.let { + queryParams.put("tokenization_channel", listOf(it.toString())) + } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -98,8 +99,8 @@ constructor( private var pageSize: Long? = null private var startingAfter: String? = null private var tokenizationChannel: TokenizationChannel? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(tokenizationListParams: TokenizationListParams) = apply { this.accountToken = tokenizationListParams.accountToken @@ -149,6 +150,11 @@ constructor( this.tokenizationChannel = tokenizationChannel } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -159,29 +165,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -194,33 +213,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): TokenizationListParams = @@ -233,14 +258,8 @@ constructor( pageSize, startingAfter, tokenizationChannel, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 7aa4f7ad..45d9e33a 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class TokenizationPauseParams constructor( private val tokenizationToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var tokenizationToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationPauseParams: TokenizationPauseParams) = apply { @@ -82,6 +82,11 @@ constructor( this.tokenizationToken = tokenizationToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -92,29 +97,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -127,33 +145,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -175,14 +199,8 @@ constructor( checkNotNull(tokenizationToken) { "`tokenizationToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 cb496fd7..5d137c97 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -23,8 +23,8 @@ class TokenizationResendActivationCodeParams constructor( private val tokenizationToken: String, private val activationMethodType: ActivationMethodType?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -36,9 +36,9 @@ constructor( return TokenizationResendActivationCodeBody(activationMethodType, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -139,9 +139,9 @@ constructor( "TokenizationResendActivationCodeBody{activationMethodType=$activationMethodType, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -172,8 +172,8 @@ constructor( private var tokenizationToken: String? = null private var activationMethodType: ActivationMethodType? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -201,6 +201,11 @@ constructor( this.activationMethodType = activationMethodType } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -211,29 +216,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -246,33 +264,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -295,14 +319,8 @@ constructor( "`tokenizationToken` is required but was not set" }, activationMethodType, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 fe55d608..887b007d 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class TokenizationRetrieveParams constructor( private val tokenizationToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun tokenizationToken(): String = tokenizationToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var tokenizationToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(tokenizationRetrieveParams: TokenizationRetrieveParams) = apply { this.tokenizationToken = tokenizationRetrieveParams.tokenizationToken @@ -72,6 +71,11 @@ constructor( this.tokenizationToken = tokenizationToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -82,29 +86,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -117,33 +134,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): TokenizationRetrieveParams = @@ -151,14 +174,8 @@ constructor( checkNotNull(tokenizationToken) { "`tokenizationToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 0849446d..19bfcfdc 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -29,8 +29,8 @@ constructor( private val deviceScore: Long?, private val entity: String?, private val walletRecommendedDecision: WalletRecommendedDecision?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -64,9 +64,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = TokenizationSimulateBody.Builder::class) @NoAutoDetect @@ -249,9 +249,9 @@ constructor( "TokenizationSimulateBody{cvv=$cvv, expirationDate=$expirationDate, pan=$pan, tokenizationSource=$tokenizationSource, accountScore=$accountScore, deviceScore=$deviceScore, entity=$entity, walletRecommendedDecision=$walletRecommendedDecision, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -288,8 +288,8 @@ constructor( private var deviceScore: Long? = null private var entity: String? = null private var walletRecommendedDecision: WalletRecommendedDecision? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationSimulateParams: TokenizationSimulateParams) = apply { @@ -344,6 +344,11 @@ constructor( this.walletRecommendedDecision = walletRecommendedDecision } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -354,29 +359,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -389,33 +407,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -444,14 +468,8 @@ constructor( deviceScore, entity, walletRecommendedDecision, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 db2a525c..a50e8288 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 @@ -2,10 +2,10 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -13,8 +13,8 @@ import java.util.Objects class TokenizationUnpauseParams constructor( private val tokenizationToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -24,9 +24,9 @@ constructor( return additionalBodyProperties.ifEmpty { null } } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -35,9 +35,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -67,8 +67,8 @@ constructor( class Builder { private var tokenizationToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(tokenizationUnpauseParams: TokenizationUnpauseParams) = apply { @@ -82,6 +82,11 @@ constructor( this.tokenizationToken = tokenizationToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -92,29 +97,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -127,33 +145,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -175,14 +199,8 @@ constructor( checkNotNull(tokenizationToken) { "`tokenizationToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 fb4da0ee..2c28249b 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class TokenizationUpdateDigitalCardArtParams constructor( private val tokenizationToken: String, private val digitalCardArtToken: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -32,9 +32,9 @@ constructor( return TokenizationUpdateDigitalCardArtBody(digitalCardArtToken, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -136,9 +136,9 @@ constructor( "TokenizationUpdateDigitalCardArtBody{digitalCardArtToken=$digitalCardArtToken, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -169,8 +169,8 @@ constructor( private var tokenizationToken: String? = null private var digitalCardArtToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -199,6 +199,11 @@ constructor( this.digitalCardArtToken = digitalCardArtToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -209,29 +214,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -244,33 +262,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -293,14 +317,8 @@ constructor( "`tokenizationToken` is required but was not set" }, digitalCardArtToken, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 5341add8..0bce1a2f 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class TransactionEnhancedCommercialDataRetrieveParams constructor( private val transactionToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun transactionToken(): String = transactionToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var transactionToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( transactionEnhancedCommercialDataRetrieveParams: @@ -77,6 +76,11 @@ constructor( this.transactionToken = transactionToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -87,29 +91,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -122,46 +139,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): TransactionEnhancedCommercialDataRetrieveParams = TransactionEnhancedCommercialDataRetrieveParams( checkNotNull(transactionToken) { "`transactionToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 7203f7fc..37605e20 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class TransactionEventEnhancedCommercialDataRetrieveParams constructor( private val eventToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun eventToken(): String = eventToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var eventToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from( transactionEventEnhancedCommercialDataRetrieveParams: @@ -77,6 +76,11 @@ constructor( fun eventToken(eventToken: String) = apply { this.eventToken = eventToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -87,29 +91,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -122,46 +139,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): TransactionEventEnhancedCommercialDataRetrieveParams = TransactionEventEnhancedCommercialDataRetrieveParams( checkNotNull(eventToken) { "`eventToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 22742555..acfcb850 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 @@ -3,13 +3,12 @@ package com.lithic.api.models import com.fasterxml.jackson.annotation.JsonCreator -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* import java.time.OffsetDateTime @@ -26,8 +25,8 @@ constructor( private val pageSize: Long?, private val result: Result?, private val startingAfter: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun accountToken(): String? = accountToken @@ -46,29 +45,29 @@ constructor( fun startingAfter(): String? = startingAfter - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> { - val params = mutableMapOf>() - this.accountToken?.let { params.put("account_token", listOf(it.toString())) } + internal fun getQueryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.accountToken?.let { queryParams.put("account_token", listOf(it.toString())) } this.begin?.let { - params.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("begin", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.cardToken?.let { params.put("card_token", listOf(it.toString())) } + this.cardToken?.let { queryParams.put("card_token", listOf(it.toString())) } this.end?.let { - params.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) + queryParams.put("end", listOf(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it))) } - this.endingBefore?.let { params.put("ending_before", listOf(it.toString())) } - this.pageSize?.let { params.put("page_size", listOf(it.toString())) } - this.result?.let { params.put("result", listOf(it.toString())) } - this.startingAfter?.let { params.put("starting_after", listOf(it.toString())) } - params.putAll(additionalQueryParams) - return params.toImmutable() + this.endingBefore?.let { queryParams.put("ending_before", listOf(it.toString())) } + this.pageSize?.let { queryParams.put("page_size", listOf(it.toString())) } + this.result?.let { queryParams.put("result", listOf(it.toString())) } + this.startingAfter?.let { queryParams.put("starting_after", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -103,8 +102,8 @@ constructor( private var pageSize: Long? = null private var result: Result? = null private var startingAfter: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(transactionListParams: TransactionListParams) = apply { this.accountToken = transactionListParams.accountToken @@ -158,6 +157,11 @@ constructor( */ fun startingAfter(startingAfter: String) = apply { this.startingAfter = startingAfter } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -168,29 +172,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -203,33 +220,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): TransactionListParams = @@ -242,14 +265,8 @@ constructor( pageSize, result, startingAfter, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } 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 d84ac67a..100ecf0d 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 @@ -2,25 +2,24 @@ package com.lithic.api.models -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.NoAutoDetect -import com.lithic.api.core.toImmutable +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.util.Objects class TransactionRetrieveParams constructor( private val transactionToken: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, ) { fun transactionToken(): String = transactionToken - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams fun getPathParam(index: Int): String { return when (index) { @@ -29,9 +28,9 @@ constructor( } } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams override fun equals(other: Any?): Boolean { if (this === other) { @@ -59,8 +58,8 @@ constructor( class Builder { private var transactionToken: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() internal fun from(transactionRetrieveParams: TransactionRetrieveParams) = apply { this.transactionToken = transactionRetrieveParams.transactionToken @@ -72,6 +71,11 @@ constructor( this.transactionToken = transactionToken } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -82,29 +86,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -117,46 +134,46 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun build(): TransactionRetrieveParams = TransactionRetrieveParams( checkNotNull(transactionToken) { "`transactionToken` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), ) } } 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 c849a69a..6726c503 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class TransactionSimulateAuthorizationAdviceParams constructor( private val token: String, private val amount: Long, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -36,9 +36,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = TransactionSimulateAuthorizationAdviceBody.Builder::class) @NoAutoDetect @@ -138,9 +138,9 @@ constructor( "TransactionSimulateAuthorizationAdviceBody{token=$token, amount=$amount, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -171,8 +171,8 @@ constructor( private var token: String? = null private var amount: Long? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -199,6 +199,11 @@ constructor( */ fun amount(amount: Long) = apply { this.amount = amount } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -209,29 +214,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -244,33 +262,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -291,14 +315,8 @@ constructor( TransactionSimulateAuthorizationAdviceParams( checkNotNull(token) { "`token` is required but was not set" }, checkNotNull(amount) { "`amount` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 e56f5b58..40cae04a 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -30,8 +30,8 @@ constructor( private val merchantCurrency: String?, private val partialApprovalCapable: Boolean?, private val status: Status?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -68,9 +68,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = TransactionSimulateAuthorizationBody.Builder::class) @NoAutoDetect @@ -314,9 +314,9 @@ constructor( "TransactionSimulateAuthorizationBody{amount=$amount, descriptor=$descriptor, pan=$pan, mcc=$mcc, merchantAcceptorId=$merchantAcceptorId, merchantAmount=$merchantAmount, merchantCurrency=$merchantCurrency, partialApprovalCapable=$partialApprovalCapable, status=$status, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -354,8 +354,8 @@ constructor( private var merchantCurrency: String? = null private var partialApprovalCapable: Boolean? = null private var status: Status? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -444,6 +444,11 @@ constructor( */ fun status(status: Status) = apply { this.status = status } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -454,29 +459,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -489,33 +507,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -543,14 +567,8 @@ constructor( merchantCurrency, partialApprovalCapable, status, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 d740887e..aabb6e41 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -19,8 +19,8 @@ class TransactionSimulateClearingParams constructor( private val token: String, private val amount: Long?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -36,9 +36,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = TransactionSimulateClearingBody.Builder::class) @NoAutoDetect @@ -142,9 +142,9 @@ constructor( "TransactionSimulateClearingBody{token=$token, amount=$amount, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -175,8 +175,8 @@ constructor( private var token: String? = null private var amount: Long? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(transactionSimulateClearingParams: TransactionSimulateClearingParams) = @@ -201,6 +201,11 @@ constructor( */ fun amount(amount: Long) = apply { this.amount = amount } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -211,29 +216,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -246,33 +264,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -293,14 +317,8 @@ constructor( TransactionSimulateClearingParams( checkNotNull(token) { "`token` is required but was not set" }, amount, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 66b82315..bb80dfbe 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -22,8 +22,8 @@ constructor( private val pan: String, private val mcc: String?, private val merchantAcceptorId: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -48,9 +48,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = TransactionSimulateCreditAuthorizationBody.Builder::class) @NoAutoDetect @@ -195,9 +195,9 @@ constructor( "TransactionSimulateCreditAuthorizationBody{amount=$amount, descriptor=$descriptor, pan=$pan, mcc=$mcc, merchantAcceptorId=$merchantAcceptorId, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -231,8 +231,8 @@ constructor( private var pan: String? = null private var mcc: String? = null private var merchantAcceptorId: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -279,6 +279,11 @@ constructor( this.merchantAcceptorId = merchantAcceptorId } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -289,29 +294,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -324,33 +342,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -374,14 +398,8 @@ constructor( checkNotNull(pan) { "`pan` is required but was not set" }, mcc, merchantAcceptorId, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 a45279b7..4c11c956 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -20,8 +20,8 @@ constructor( private val amount: Long, private val descriptor: String, private val pan: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -40,9 +40,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = TransactionSimulateReturnBody.Builder::class) @NoAutoDetect @@ -143,9 +143,9 @@ constructor( "TransactionSimulateReturnBody{amount=$amount, descriptor=$descriptor, pan=$pan, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -177,8 +177,8 @@ constructor( private var amount: Long? = null private var descriptor: String? = null private var pan: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(transactionSimulateReturnParams: TransactionSimulateReturnParams) = @@ -200,6 +200,11 @@ constructor( /** Sixteen digit card number. */ fun pan(pan: String) = apply { this.pan = pan } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -210,29 +215,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -245,33 +263,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -293,14 +317,8 @@ constructor( checkNotNull(amount) { "`amount` is required but was not set" }, checkNotNull(descriptor) { "`descriptor` is required but was not set" }, checkNotNull(pan) { "`pan` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 5741aa2d..7262cf15 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -18,8 +18,8 @@ import java.util.Objects class TransactionSimulateReturnReversalParams constructor( private val token: String, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -29,9 +29,9 @@ constructor( return TransactionSimulateReturnReversalBody(token, additionalBodyProperties) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = TransactionSimulateReturnReversalBody.Builder::class) @NoAutoDetect @@ -112,9 +112,9 @@ constructor( "TransactionSimulateReturnReversalBody{token=$token, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -144,8 +144,8 @@ constructor( class Builder { private var token: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from( @@ -162,6 +162,11 @@ constructor( /** The transaction token returned from the /v1/simulate/authorize response. */ fun token(token: String) = apply { this.token = token } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -172,29 +177,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -207,33 +225,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -253,14 +277,8 @@ constructor( fun build(): TransactionSimulateReturnReversalParams = TransactionSimulateReturnReversalParams( checkNotNull(token) { "`token` is required but was not set" }, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 ba8baa31..77ce738d 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 @@ -7,13 +7,13 @@ import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.Enum import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonField import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.errors.LithicInvalidDataException import com.lithic.api.models.* @@ -24,8 +24,8 @@ constructor( private val token: String, private val amount: Long?, private val type: Type?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -44,9 +44,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = TransactionSimulateVoidBody.Builder::class) @NoAutoDetect @@ -160,9 +160,9 @@ constructor( "TransactionSimulateVoidBody{token=$token, amount=$amount, type=$type, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -194,8 +194,8 @@ constructor( private var token: String? = null private var amount: Long? = null private var type: Type? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(transactionSimulateVoidParams: TransactionSimulateVoidParams) = apply { @@ -223,6 +223,11 @@ constructor( */ fun type(type: Type) = apply { this.type = type } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -233,29 +238,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -268,33 +286,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -316,14 +340,8 @@ constructor( checkNotNull(token) { "`token` is required but was not set" }, amount, type, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } 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 a0096255..c1483b95 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 @@ -6,11 +6,11 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter import com.fasterxml.jackson.annotation.JsonAnySetter import com.fasterxml.jackson.annotation.JsonProperty import com.fasterxml.jackson.databind.annotation.JsonDeserialize -import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.core.ExcludeMissing import com.lithic.api.core.JsonValue import com.lithic.api.core.NoAutoDetect +import com.lithic.api.core.http.Headers +import com.lithic.api.core.http.QueryParams import com.lithic.api.core.toImmutable import com.lithic.api.models.* import java.util.Objects @@ -22,8 +22,8 @@ constructor( private val to: String, private val token: String?, private val memo: String?, - private val additionalHeaders: Map>, - private val additionalQueryParams: Map>, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, private val additionalBodyProperties: Map, ) { @@ -48,9 +48,9 @@ constructor( ) } - internal fun getHeaders(): Map> = additionalHeaders + internal fun getHeaders(): Headers = additionalHeaders - internal fun getQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): QueryParams = additionalQueryParams @JsonDeserialize(builder = TransferCreateBody.Builder::class) @NoAutoDetect @@ -193,9 +193,9 @@ constructor( "TransferCreateBody{amount=$amount, from=$from, to=$to, token=$token, memo=$memo, additionalProperties=$additionalProperties}" } - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Headers = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + fun _additionalQueryParams(): QueryParams = additionalQueryParams fun _additionalBodyProperties(): Map = additionalBodyProperties @@ -229,8 +229,8 @@ constructor( private var to: String? = null private var token: String? = null private var memo: String? = null - private var additionalHeaders: ListMultimap = ArrayListMultimap.create() - private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() private var additionalBodyProperties: MutableMap = mutableMapOf() internal fun from(transferCreateParams: TransferCreateParams) = apply { @@ -271,6 +271,11 @@ constructor( /** Optional descriptor for the transfer. */ fun memo(memo: String) = apply { this.memo = memo } + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + fun additionalHeaders(additionalHeaders: Map>) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -281,29 +286,42 @@ constructor( } fun putAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.putAll(name, values) + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) } fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::putAdditionalHeaders) + this.additionalHeaders.putAll(additionalHeaders) } fun replaceAdditionalHeaders(name: String, value: String) = apply { - additionalHeaders.replaceValues(name, listOf(value)) + additionalHeaders.replace(name, value) } fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { - additionalHeaders.replaceValues(name, values) + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) } fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(::replaceAdditionalHeaders) + this.additionalHeaders.replaceAll(additionalHeaders) } - fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } fun removeAllAdditionalHeaders(names: Set) = apply { - names.forEach(::removeAdditionalHeaders) + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } fun additionalQueryParams(additionalQueryParams: Map>) = apply { @@ -316,33 +334,39 @@ constructor( } fun putAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.putAll(key, values) + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) } fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::putAdditionalQueryParams) + this.additionalQueryParams.putAll(additionalQueryParams) } fun replaceAdditionalQueryParams(key: String, value: String) = apply { - additionalQueryParams.replaceValues(key, listOf(value)) + additionalQueryParams.replace(key, value) } fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { - additionalQueryParams.replaceValues(key, values) + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) } fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(::replaceAdditionalQueryParams) + this.additionalQueryParams.replaceAll(additionalQueryParams) } - fun removeAdditionalQueryParams(key: String) = apply { - additionalQueryParams.removeAll(key) - } + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } fun removeAllAdditionalQueryParams(keys: Set) = apply { - keys.forEach(::removeAdditionalQueryParams) + additionalQueryParams.removeAll(keys) } fun additionalBodyProperties(additionalBodyProperties: Map) = apply { @@ -366,14 +390,8 @@ constructor( checkNotNull(to) { "`to` is required but was not set" }, token, memo, - additionalHeaders - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), - additionalQueryParams - .asMap() - .mapValues { it.value.toList().toImmutable() } - .toImmutable(), + additionalHeaders.build(), + additionalQueryParams.build(), additionalBodyProperties.toImmutable(), ) } diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AccountHolderServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AccountHolderServiceAsyncImpl.kt index 0e67abfe..996a69c8 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AccountHolderServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AccountHolderServiceAsyncImpl.kt @@ -57,9 +57,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "account_holders") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -93,9 +93,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "account_holders", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -122,9 +122,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "account_holders", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -154,9 +154,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "account_holders") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -198,9 +198,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "account_holders", params.getPathParam(0), "documents") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -234,9 +234,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "account_holders", params.getPathParam(0), "resubmit") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -283,9 +283,9 @@ constructor( "documents", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -311,9 +311,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "account_holders", "enrollment_document_review") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -345,9 +345,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "account_holders", "enrollment_review") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -391,9 +391,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "account_holders", params.getPathParam(0), "documents") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AccountServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AccountServiceAsyncImpl.kt index e27d6fde..42d105d9 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AccountServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AccountServiceAsyncImpl.kt @@ -39,9 +39,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -71,9 +71,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -101,9 +101,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -135,9 +135,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "accounts", params.getPathParam(0), "spend_limits") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AggregateBalanceServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AggregateBalanceServiceAsyncImpl.kt index ed317c0c..88bc8ca5 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AggregateBalanceServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AggregateBalanceServiceAsyncImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "aggregate_balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AuthStreamEnrollmentServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AuthStreamEnrollmentServiceAsyncImpl.kt index 45f844fd..a667f2a0 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AuthStreamEnrollmentServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/AuthStreamEnrollmentServiceAsyncImpl.kt @@ -42,9 +42,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "auth_stream", "secret") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -74,9 +74,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "auth_stream", "secret", "rotate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/BalanceServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/BalanceServiceAsyncImpl.kt index 68538e5b..e5d882a3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/BalanceServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/BalanceServiceAsyncImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/BookTransferServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/BookTransferServiceAsyncImpl.kt index 604d9478..171b6fc1 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/BookTransferServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/BookTransferServiceAsyncImpl.kt @@ -40,9 +40,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "book_transfers") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -69,9 +69,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "book_transfers", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -98,9 +98,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "book_transfers") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -127,9 +127,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "book_transfers", params.getPathParam(0), "reverse") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/CardProgramServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/CardProgramServiceAsyncImpl.kt index 7de8d025..2dbd4b1c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/CardProgramServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/CardProgramServiceAsyncImpl.kt @@ -35,9 +35,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "card_programs", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -64,9 +64,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "card_programs") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/CardServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/CardServiceAsyncImpl.kt index eace5be4..f641d551 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/CardServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/CardServiceAsyncImpl.kt @@ -69,9 +69,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -98,9 +98,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -128,9 +128,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "cards", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -158,9 +158,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -207,9 +207,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "embed", "card") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -236,9 +236,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards", params.getPathParam(0), "provision") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -266,9 +266,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards", params.getPathParam(0), "reissue") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -296,9 +296,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards", params.getPathParam(0), "renew") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -330,9 +330,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", params.getPathParam(0), "spend_limits") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -363,9 +363,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards", "search_by_pan") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/DigitalCardArtServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/DigitalCardArtServiceAsyncImpl.kt index 279425f5..4ccb80f5 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/DigitalCardArtServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/DigitalCardArtServiceAsyncImpl.kt @@ -35,9 +35,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "digital_card_art", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -64,9 +64,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "digital_card_art") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/DisputeServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/DisputeServiceAsyncImpl.kt index 9417e79d..de3cf57a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/DisputeServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/DisputeServiceAsyncImpl.kt @@ -45,9 +45,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "disputes") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -74,9 +74,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "disputes", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -102,9 +102,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "disputes", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -132,9 +132,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "disputes") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -161,9 +161,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.DELETE) .addPathSegments("v1", "disputes", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -199,9 +199,9 @@ constructor( "evidences", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -234,9 +234,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "disputes", params.getPathParam(0), "evidences") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -264,9 +264,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "disputes", params.getPathParam(0), "evidences") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -299,9 +299,9 @@ constructor( "evidences", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/EventServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/EventServiceAsyncImpl.kt index 88e39486..3ec97da0 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/EventServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/EventServiceAsyncImpl.kt @@ -45,9 +45,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "events", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -74,9 +74,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "events") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -104,9 +104,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "events", params.getPathParam(0), "attempts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ExternalBankAccountServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ExternalBankAccountServiceAsyncImpl.kt index c0e5ed2d..16dbabca 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ExternalBankAccountServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ExternalBankAccountServiceAsyncImpl.kt @@ -53,9 +53,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_bank_accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -83,9 +83,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "external_bank_accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -112,9 +112,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "external_bank_accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -142,9 +142,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "external_bank_accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -177,9 +177,9 @@ constructor( params.getPathParam(0), "retry_micro_deposits" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -212,9 +212,9 @@ constructor( params.getPathParam(0), "retry_prenote" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ExternalPaymentServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ExternalPaymentServiceAsyncImpl.kt index 7fc31b48..ca6c5423 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ExternalPaymentServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ExternalPaymentServiceAsyncImpl.kt @@ -41,9 +41,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -70,9 +70,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "external_payments", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -99,9 +99,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "external_payments") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -128,9 +128,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments", params.getPathParam(0), "cancel") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -157,9 +157,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments", params.getPathParam(0), "release") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -186,9 +186,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments", params.getPathParam(0), "reverse") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -215,9 +215,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments", params.getPathParam(0), "settle") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/FinancialAccountServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/FinancialAccountServiceAsyncImpl.kt index ddd5931b..9c5f54b5 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/FinancialAccountServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/FinancialAccountServiceAsyncImpl.kt @@ -76,9 +76,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "financial_accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -105,9 +105,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -133,9 +133,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "financial_accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -163,9 +163,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -193,9 +193,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "financial_accounts", params.getPathParam(0), "charge_off") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ManagementOperationServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ManagementOperationServiceAsyncImpl.kt index 8a6fb96b..3788a05b 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ManagementOperationServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ManagementOperationServiceAsyncImpl.kt @@ -39,9 +39,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "management_operations") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -69,9 +69,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "management_operations", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -98,9 +98,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "management_operations") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -128,9 +128,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "management_operations", params.getPathParam(0), "reverse") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/PaymentServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/PaymentServiceAsyncImpl.kt index 50f9bcf4..e35d6d70 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/PaymentServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/PaymentServiceAsyncImpl.kt @@ -48,9 +48,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "payments") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -77,9 +77,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "payments", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -106,9 +106,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "payments") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -135,9 +135,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "payments", params.getPathParam(0), "retry") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -165,9 +165,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "payments", params.getPathParam(0), "action") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -195,9 +195,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "payments", "receipt") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -225,9 +225,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "payments", "release") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -255,9 +255,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "payments", "return") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ResponderEndpointServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ResponderEndpointServiceAsyncImpl.kt index 000ce757..43c4ad27 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ResponderEndpointServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/ResponderEndpointServiceAsyncImpl.kt @@ -39,9 +39,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "responder_endpoints") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -67,9 +67,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.DELETE) .addPathSegments("v1", "responder_endpoints") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -91,9 +91,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "responder_endpoints") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TokenizationDecisioningServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TokenizationDecisioningServiceAsyncImpl.kt index 33127e2e..0166ade4 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TokenizationDecisioningServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TokenizationDecisioningServiceAsyncImpl.kt @@ -42,9 +42,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "tokenization_decisioning", "secret") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -74,9 +74,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenization_decisioning", "secret", "rotate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TokenizationServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TokenizationServiceAsyncImpl.kt index c8627b69..9b7f2fbe 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TokenizationServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TokenizationServiceAsyncImpl.kt @@ -47,9 +47,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "tokenizations", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -76,9 +76,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "tokenizations") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -112,9 +112,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenizations", params.getPathParam(0), "activate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -143,9 +143,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenizations", params.getPathParam(0), "deactivate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -170,9 +170,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenizations", params.getPathParam(0), "pause") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -208,9 +208,9 @@ constructor( params.getPathParam(0), "resend_activation_code" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -235,9 +235,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "tokenizations") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -270,9 +270,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenizations", params.getPathParam(0), "unpause") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -307,9 +307,9 @@ constructor( params.getPathParam(0), "update_digital_card_art" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TransactionServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TransactionServiceAsyncImpl.kt index ffd51feb..beb37db8 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TransactionServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TransactionServiceAsyncImpl.kt @@ -68,9 +68,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "transactions", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -100,9 +100,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "transactions") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -137,9 +137,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "authorize") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -171,9 +171,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "authorization_advice") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -206,9 +206,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "clearing") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -240,9 +240,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "credit_authorization_advice") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -273,9 +273,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "return") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -307,9 +307,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "return_reversal") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -343,9 +343,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "void") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TransferServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TransferServiceAsyncImpl.kt index 64f05252..043dbe43 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TransferServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/TransferServiceAsyncImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "transfer") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/authRules/V2ServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/authRules/V2ServiceAsyncImpl.kt index d38de848..1a0c49c1 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/authRules/V2ServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/authRules/V2ServiceAsyncImpl.kt @@ -48,9 +48,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -77,9 +77,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v2", "auth_rules", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -105,9 +105,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v2", "auth_rules", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -135,9 +135,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v2", "auth_rules") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -168,9 +168,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules", params.getPathParam(0), "apply") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -202,9 +202,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules", params.getPathParam(0), "draft") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -234,9 +234,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules", params.getPathParam(0), "promote") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -308,9 +308,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules", params.getPathParam(0), "report") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/AggregateBalanceServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/AggregateBalanceServiceAsyncImpl.kt index 3d2be7b9..952cf244 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/AggregateBalanceServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/AggregateBalanceServiceAsyncImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", "aggregate_balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/BalanceServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/BalanceServiceAsyncImpl.kt index 3d7f115d..76952819 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/BalanceServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/BalanceServiceAsyncImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", params.getPathParam(0), "balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/FinancialTransactionServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/FinancialTransactionServiceAsyncImpl.kt index 6de52fdd..7ac41728 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/FinancialTransactionServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/cards/FinancialTransactionServiceAsyncImpl.kt @@ -41,9 +41,9 @@ constructor( "financial_transactions", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -70,9 +70,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", params.getPathParam(0), "financial_transactions") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/creditProducts/ExtendedCreditServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/creditProducts/ExtendedCreditServiceAsyncImpl.kt index 9ad1c36d..01a7f1e9 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/creditProducts/ExtendedCreditServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/creditProducts/ExtendedCreditServiceAsyncImpl.kt @@ -33,9 +33,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "credit_products", params.getPathParam(0), "extended_credit") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/events/SubscriptionServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/events/SubscriptionServiceAsyncImpl.kt index f33941f7..f3e0dcb9 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/events/SubscriptionServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/events/SubscriptionServiceAsyncImpl.kt @@ -48,9 +48,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "event_subscriptions") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -77,9 +77,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -105,9 +105,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -135,9 +135,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "event_subscriptions") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -163,9 +163,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.DELETE) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -187,9 +187,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0), "attempts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -215,9 +215,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0), "recover") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -247,9 +247,9 @@ constructor( params.getPathParam(0), "replay_missing" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -271,9 +271,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0), "secret") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -307,9 +307,9 @@ constructor( "secret", "rotate" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -336,9 +336,9 @@ constructor( params.getPathParam(0), "send_example" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/externalBankAccounts/MicroDepositServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/externalBankAccounts/MicroDepositServiceAsyncImpl.kt index 2ef3d0e8..de71bf7f 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/externalBankAccounts/MicroDepositServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/externalBankAccounts/MicroDepositServiceAsyncImpl.kt @@ -40,9 +40,9 @@ constructor( params.getPathParam(0), "micro_deposits" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/BalanceServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/BalanceServiceAsyncImpl.kt index be6b723c..7ad689e5 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/BalanceServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/BalanceServiceAsyncImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts", params.getPathParam(0), "balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/CreditConfigurationServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/CreditConfigurationServiceAsyncImpl.kt index 2c38ac75..bba368c1 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/CreditConfigurationServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/CreditConfigurationServiceAsyncImpl.kt @@ -41,9 +41,9 @@ constructor( params.getPathParam(0), "credit_configuration" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -75,9 +75,9 @@ constructor( params.getPathParam(0), "credit_configuration" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/FinancialTransactionServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/FinancialTransactionServiceAsyncImpl.kt index 5e4c957a..3b3cda6a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/FinancialTransactionServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/FinancialTransactionServiceAsyncImpl.kt @@ -41,9 +41,9 @@ constructor( "financial_transactions", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -75,9 +75,9 @@ constructor( params.getPathParam(0), "financial_transactions" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/LoanTapeServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/LoanTapeServiceAsyncImpl.kt index 22e49e60..a935062a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/LoanTapeServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/LoanTapeServiceAsyncImpl.kt @@ -41,9 +41,9 @@ constructor( "loan_tapes", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -70,9 +70,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts", params.getPathParam(0), "loan_tapes") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/StatementServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/StatementServiceAsyncImpl.kt index 5bef8b7c..81dfa0ef 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/StatementServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/StatementServiceAsyncImpl.kt @@ -47,9 +47,9 @@ constructor( "statements", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -76,9 +76,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts", params.getPathParam(0), "statements") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/statements/LineItemServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/statements/LineItemServiceAsyncImpl.kt index 2f9fd8e9..54f62a44 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/statements/LineItemServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/financialAccounts/statements/LineItemServiceAsyncImpl.kt @@ -43,9 +43,9 @@ constructor( params.getPathParam(1), "line_items" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/reports/SettlementServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/reports/SettlementServiceAsyncImpl.kt index a77ac0ed..b1fad5f5 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/reports/SettlementServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/reports/SettlementServiceAsyncImpl.kt @@ -36,9 +36,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "reports", "settlement", "details", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -65,9 +65,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "reports", "settlement", "summary", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/threeDS/AuthenticationServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/threeDS/AuthenticationServiceAsyncImpl.kt index 2cc4f6a7..b21886ca 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/threeDS/AuthenticationServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/threeDS/AuthenticationServiceAsyncImpl.kt @@ -37,9 +37,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "three_ds_authentication", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -70,9 +70,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_authentication", "simulate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/threeDS/DecisioningServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/threeDS/DecisioningServiceAsyncImpl.kt index 0a20a333..1116d93f 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/threeDS/DecisioningServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/threeDS/DecisioningServiceAsyncImpl.kt @@ -40,9 +40,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_decisioning", "challenge_response") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -71,9 +71,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "three_ds_decisioning", "secret") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> @@ -103,9 +103,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_decisioning", "secret", "rotate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -131,9 +131,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_decisioning", "simulate", "challenge") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -163,9 +163,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_decisioning", "simulate", "challenge_response") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/transactions/EnhancedCommercialDataServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/transactions/EnhancedCommercialDataServiceAsyncImpl.kt index 2f6be7cb..2fddc774 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/transactions/EnhancedCommercialDataServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/transactions/EnhancedCommercialDataServiceAsyncImpl.kt @@ -42,9 +42,9 @@ constructor( params.getPathParam(0), "enhanced_commercial_data" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/transactions/events/EnhancedCommercialDataServiceAsyncImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/transactions/events/EnhancedCommercialDataServiceAsyncImpl.kt index 88cdfb27..784c2767 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/transactions/events/EnhancedCommercialDataServiceAsyncImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/async/transactions/events/EnhancedCommercialDataServiceAsyncImpl.kt @@ -42,9 +42,9 @@ constructor( params.getPathParam(0), "enhanced_commercial_data" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.executeAsync(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AccountHolderServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AccountHolderServiceImpl.kt index 10e233f2..2e5aba5a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AccountHolderServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AccountHolderServiceImpl.kt @@ -57,9 +57,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "account_holders") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -93,9 +93,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "account_holders", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -122,9 +122,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "account_holders", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -154,9 +154,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "account_holders") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -198,9 +198,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "account_holders", params.getPathParam(0), "documents") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -234,9 +234,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "account_holders", params.getPathParam(0), "resubmit") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -283,9 +283,9 @@ constructor( "documents", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -311,9 +311,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "account_holders", "enrollment_document_review") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -345,9 +345,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "account_holders", "enrollment_review") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -391,9 +391,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "account_holders", params.getPathParam(0), "documents") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AccountServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AccountServiceImpl.kt index bd0cae86..f53f07af 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AccountServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AccountServiceImpl.kt @@ -36,9 +36,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -65,9 +65,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -92,9 +92,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -126,9 +126,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "accounts", params.getPathParam(0), "spend_limits") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AggregateBalanceServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AggregateBalanceServiceImpl.kt index 276852ae..381e0ad6 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AggregateBalanceServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AggregateBalanceServiceImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "aggregate_balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AuthStreamEnrollmentServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AuthStreamEnrollmentServiceImpl.kt index 1eb77a1a..3dfd26bd 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AuthStreamEnrollmentServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/AuthStreamEnrollmentServiceImpl.kt @@ -42,9 +42,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "auth_stream", "secret") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -74,9 +74,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "auth_stream", "secret", "rotate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/BalanceServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/BalanceServiceImpl.kt index 495901af..43ac136a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/BalanceServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/BalanceServiceImpl.kt @@ -31,9 +31,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/BookTransferServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/BookTransferServiceImpl.kt index 1eec9333..829faed3 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/BookTransferServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/BookTransferServiceImpl.kt @@ -40,9 +40,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "book_transfers") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -69,9 +69,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "book_transfers", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -98,9 +98,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "book_transfers") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -127,9 +127,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "book_transfers", params.getPathParam(0), "reverse") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/CardProgramServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/CardProgramServiceImpl.kt index 91e28504..91e5ff1d 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/CardProgramServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/CardProgramServiceImpl.kt @@ -35,9 +35,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "card_programs", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -64,9 +64,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "card_programs") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/CardServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/CardServiceImpl.kt index 9c912d45..9684ca9a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/CardServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/CardServiceImpl.kt @@ -69,9 +69,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -95,9 +95,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -125,9 +125,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "cards", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -151,9 +151,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -200,9 +200,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "embed", "card") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -229,9 +229,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards", params.getPathParam(0), "provision") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -259,9 +259,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards", params.getPathParam(0), "reissue") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -289,9 +289,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards", params.getPathParam(0), "renew") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -323,9 +323,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", params.getPathParam(0), "spend_limits") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -353,9 +353,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "cards", "search_by_pan") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/DigitalCardArtServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/DigitalCardArtServiceImpl.kt index f2adea02..9f3a5635 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/DigitalCardArtServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/DigitalCardArtServiceImpl.kt @@ -35,9 +35,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "digital_card_art", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -64,9 +64,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "digital_card_art") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/DisputeServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/DisputeServiceImpl.kt index 0b4961df..06472077 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/DisputeServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/DisputeServiceImpl.kt @@ -42,9 +42,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "disputes") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -68,9 +68,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "disputes", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -93,9 +93,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "disputes", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -120,9 +120,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "disputes") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -146,9 +146,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.DELETE) .addPathSegments("v1", "disputes", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -184,9 +184,9 @@ constructor( "evidences", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -219,9 +219,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "disputes", params.getPathParam(0), "evidences") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -249,9 +249,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "disputes", params.getPathParam(0), "evidences") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -284,9 +284,9 @@ constructor( "evidences", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/EventServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/EventServiceImpl.kt index fecae91c..e5bcb675 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/EventServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/EventServiceImpl.kt @@ -42,9 +42,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "events", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -67,9 +67,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "events") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -97,9 +97,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "events", params.getPathParam(0), "attempts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ExternalBankAccountServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ExternalBankAccountServiceImpl.kt index 3dcf7c1b..5b8195fc 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ExternalBankAccountServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ExternalBankAccountServiceImpl.kt @@ -53,9 +53,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_bank_accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -83,9 +83,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "external_bank_accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -112,9 +112,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "external_bank_accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -142,9 +142,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "external_bank_accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -177,9 +177,9 @@ constructor( params.getPathParam(0), "retry_micro_deposits" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -212,9 +212,9 @@ constructor( params.getPathParam(0), "retry_prenote" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ExternalPaymentServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ExternalPaymentServiceImpl.kt index 66c17651..d2d66b11 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ExternalPaymentServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ExternalPaymentServiceImpl.kt @@ -41,9 +41,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -70,9 +70,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "external_payments", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -99,9 +99,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "external_payments") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -128,9 +128,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments", params.getPathParam(0), "cancel") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -157,9 +157,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments", params.getPathParam(0), "release") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -186,9 +186,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments", params.getPathParam(0), "reverse") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -215,9 +215,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "external_payments", params.getPathParam(0), "settle") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/FinancialAccountServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/FinancialAccountServiceImpl.kt index d44cae1f..478fdc2a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/FinancialAccountServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/FinancialAccountServiceImpl.kt @@ -74,9 +74,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "financial_accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -103,9 +103,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -131,9 +131,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "financial_accounts", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -161,9 +161,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -191,9 +191,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "financial_accounts", params.getPathParam(0), "charge_off") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ManagementOperationServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ManagementOperationServiceImpl.kt index 2a49b9ca..371e6d4a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ManagementOperationServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ManagementOperationServiceImpl.kt @@ -39,9 +39,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "management_operations") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -69,9 +69,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "management_operations", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -98,9 +98,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "management_operations") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -128,9 +128,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "management_operations", params.getPathParam(0), "reverse") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/PaymentServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/PaymentServiceImpl.kt index 46b74c98..678321b6 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/PaymentServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/PaymentServiceImpl.kt @@ -48,9 +48,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "payments") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -74,9 +74,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "payments", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -100,9 +100,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "payments") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -129,9 +129,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "payments", params.getPathParam(0), "retry") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -159,9 +159,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "payments", params.getPathParam(0), "action") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -189,9 +189,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "payments", "receipt") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -219,9 +219,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "payments", "release") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -249,9 +249,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "payments", "return") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ResponderEndpointServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ResponderEndpointServiceImpl.kt index c43c6959..f528d00e 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ResponderEndpointServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/ResponderEndpointServiceImpl.kt @@ -39,9 +39,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "responder_endpoints") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -64,9 +64,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.DELETE) .addPathSegments("v1", "responder_endpoints") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -88,9 +88,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "responder_endpoints") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TokenizationDecisioningServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TokenizationDecisioningServiceImpl.kt index 7582f131..559ddc56 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TokenizationDecisioningServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TokenizationDecisioningServiceImpl.kt @@ -42,9 +42,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "tokenization_decisioning", "secret") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -74,9 +74,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenization_decisioning", "secret", "rotate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TokenizationServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TokenizationServiceImpl.kt index ee85e964..80c5422b 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TokenizationServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TokenizationServiceImpl.kt @@ -47,9 +47,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "tokenizations", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -76,9 +76,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "tokenizations") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -109,9 +109,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenizations", params.getPathParam(0), "activate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -137,9 +137,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenizations", params.getPathParam(0), "deactivate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -164,9 +164,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenizations", params.getPathParam(0), "pause") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -202,9 +202,9 @@ constructor( params.getPathParam(0), "resend_activation_code" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -229,9 +229,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "tokenizations") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -261,9 +261,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "tokenizations", params.getPathParam(0), "unpause") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -298,9 +298,9 @@ constructor( params.getPathParam(0), "update_digital_card_art" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TransactionServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TransactionServiceImpl.kt index 6e83b335..52fe4797 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TransactionServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TransactionServiceImpl.kt @@ -67,9 +67,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "transactions", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -99,9 +99,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "transactions") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -136,9 +136,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "authorize") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -170,9 +170,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "authorization_advice") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -205,9 +205,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "clearing") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -239,9 +239,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "credit_authorization_advice") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -272,9 +272,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "return") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -306,9 +306,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "return_reversal") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -342,9 +342,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "simulate", "void") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TransferServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TransferServiceImpl.kt index 322b295d..812fc046 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TransferServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/TransferServiceImpl.kt @@ -31,9 +31,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "transfer") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/authRules/V2ServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/authRules/V2ServiceImpl.kt index ce78e599..6a4c6329 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/authRules/V2ServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/authRules/V2ServiceImpl.kt @@ -48,9 +48,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -77,9 +77,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v2", "auth_rules", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -105,9 +105,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v2", "auth_rules", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -135,9 +135,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v2", "auth_rules") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -168,9 +168,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules", params.getPathParam(0), "apply") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -202,9 +202,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules", params.getPathParam(0), "draft") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -234,9 +234,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules", params.getPathParam(0), "promote") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -308,9 +308,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v2", "auth_rules", params.getPathParam(0), "report") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/AggregateBalanceServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/AggregateBalanceServiceImpl.kt index 7435fb65..a525171f 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/AggregateBalanceServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/AggregateBalanceServiceImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", "aggregate_balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/BalanceServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/BalanceServiceImpl.kt index 78df77cb..22889939 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/BalanceServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/BalanceServiceImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", params.getPathParam(0), "balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/FinancialTransactionServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/FinancialTransactionServiceImpl.kt index 2d731ab4..d030807c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/FinancialTransactionServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/cards/FinancialTransactionServiceImpl.kt @@ -41,9 +41,9 @@ constructor( "financial_transactions", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -70,9 +70,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "cards", params.getPathParam(0), "financial_transactions") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/creditProducts/ExtendedCreditServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/creditProducts/ExtendedCreditServiceImpl.kt index 9e8f4c67..cb14c35e 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/creditProducts/ExtendedCreditServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/creditProducts/ExtendedCreditServiceImpl.kt @@ -33,9 +33,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "credit_products", params.getPathParam(0), "extended_credit") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/events/SubscriptionServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/events/SubscriptionServiceImpl.kt index 52a9761e..24519bf6 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/events/SubscriptionServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/events/SubscriptionServiceImpl.kt @@ -48,9 +48,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "event_subscriptions") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -77,9 +77,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -105,9 +105,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.PATCH) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -135,9 +135,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "event_subscriptions") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -160,9 +160,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.DELETE) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -184,9 +184,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0), "attempts") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -209,9 +209,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0), "recover") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -241,9 +241,9 @@ constructor( params.getPathParam(0), "replay_missing" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -265,9 +265,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "event_subscriptions", params.getPathParam(0), "secret") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -301,9 +301,9 @@ constructor( "secret", "rotate" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -330,9 +330,9 @@ constructor( params.getPathParam(0), "send_example" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/externalBankAccounts/MicroDepositServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/externalBankAccounts/MicroDepositServiceImpl.kt index 109549e7..2857b2c6 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/externalBankAccounts/MicroDepositServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/externalBankAccounts/MicroDepositServiceImpl.kt @@ -40,9 +40,9 @@ constructor( params.getPathParam(0), "micro_deposits" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/BalanceServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/BalanceServiceImpl.kt index 745d0fdc..877de12c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/BalanceServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/BalanceServiceImpl.kt @@ -34,9 +34,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts", params.getPathParam(0), "balances") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/CreditConfigurationServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/CreditConfigurationServiceImpl.kt index 54999e61..72e26199 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/CreditConfigurationServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/CreditConfigurationServiceImpl.kt @@ -41,9 +41,9 @@ constructor( params.getPathParam(0), "credit_configuration" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -75,9 +75,9 @@ constructor( params.getPathParam(0), "credit_configuration" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/FinancialTransactionServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/FinancialTransactionServiceImpl.kt index 21e570bc..d2dfb160 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/FinancialTransactionServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/FinancialTransactionServiceImpl.kt @@ -41,9 +41,9 @@ constructor( "financial_transactions", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -75,9 +75,9 @@ constructor( params.getPathParam(0), "financial_transactions" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/LoanTapeServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/LoanTapeServiceImpl.kt index 4d88d3ae..54de68da 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/LoanTapeServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/LoanTapeServiceImpl.kt @@ -41,9 +41,9 @@ constructor( "loan_tapes", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -70,9 +70,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts", params.getPathParam(0), "loan_tapes") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/StatementServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/StatementServiceImpl.kt index af8511d8..f2bfdb5a 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/StatementServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/StatementServiceImpl.kt @@ -47,9 +47,9 @@ constructor( "statements", params.getPathParam(1) ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -76,9 +76,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "financial_accounts", params.getPathParam(0), "statements") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/statements/LineItemServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/statements/LineItemServiceImpl.kt index 3567ea1b..68b88532 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/statements/LineItemServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/financialAccounts/statements/LineItemServiceImpl.kt @@ -41,9 +41,9 @@ constructor( params.getPathParam(1), "line_items" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/reports/SettlementServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/reports/SettlementServiceImpl.kt index 44c89292..7a858c7f 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/reports/SettlementServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/reports/SettlementServiceImpl.kt @@ -36,9 +36,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "reports", "settlement", "details", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -65,9 +65,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "reports", "settlement", "summary", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/threeDS/AuthenticationServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/threeDS/AuthenticationServiceImpl.kt index 405b3227..45ab6d7b 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/threeDS/AuthenticationServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/threeDS/AuthenticationServiceImpl.kt @@ -37,9 +37,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "three_ds_authentication", params.getPathParam(0)) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -70,9 +70,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_authentication", "simulate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/threeDS/DecisioningServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/threeDS/DecisioningServiceImpl.kt index 69246921..5d37ebdc 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/threeDS/DecisioningServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/threeDS/DecisioningServiceImpl.kt @@ -40,9 +40,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_decisioning", "challenge_response") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -71,9 +71,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.GET) .addPathSegments("v1", "three_ds_decisioning", "secret") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> @@ -103,9 +103,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_decisioning", "secret", "rotate") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .apply { params.getBody()?.also { body(json(clientOptions.jsonMapper, it)) } } .build() @@ -131,9 +131,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_decisioning", "simulate", "challenge") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() @@ -163,9 +163,9 @@ constructor( HttpRequest.builder() .method(HttpMethod.POST) .addPathSegments("v1", "three_ds_decisioning", "simulate", "challenge_response") - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .body(json(clientOptions.jsonMapper, params.getBody())) .build() diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/transactions/EnhancedCommercialDataServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/transactions/EnhancedCommercialDataServiceImpl.kt index e47964e2..4b760ea5 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/transactions/EnhancedCommercialDataServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/transactions/EnhancedCommercialDataServiceImpl.kt @@ -42,9 +42,9 @@ constructor( params.getPathParam(0), "enhanced_commercial_data" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/transactions/events/EnhancedCommercialDataServiceImpl.kt b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/transactions/events/EnhancedCommercialDataServiceImpl.kt index c10a645b..352e626c 100644 --- a/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/transactions/events/EnhancedCommercialDataServiceImpl.kt +++ b/lithic-kotlin-core/src/main/kotlin/com/lithic/api/services/blocking/transactions/events/EnhancedCommercialDataServiceImpl.kt @@ -42,9 +42,9 @@ constructor( params.getPathParam(0), "enhanced_commercial_data" ) - .putAllQueryParams(clientOptions.queryParams.asMap()) + .putAllQueryParams(clientOptions.queryParams) .replaceAllQueryParams(params.getQueryParams()) - .putAllHeaders(clientOptions.headers.asMap()) + .putAllHeaders(clientOptions.headers) .replaceAllHeaders(params.getHeaders()) .build() return clientOptions.httpClient.execute(request, requestOptions).let { response -> diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/core/http/HttpRequestTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/core/http/HttpRequestTest.kt deleted file mode 100644 index 3e5759b9..00000000 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/core/http/HttpRequestTest.kt +++ /dev/null @@ -1,22 +0,0 @@ -package com.lithic.api.core.http - -import org.assertj.core.api.Assertions.assertThat -import org.junit.jupiter.api.Test - -internal class HttpRequestTest { - - @Test - fun caseInsensitiveHeadersAccessors() { - val request = - HttpRequest.builder() - .method(HttpMethod.POST) - .putHeader("something_lowercase", "lowercase") - .putHeader("Something_Capitalized", "Capitalized") - .putHeader("SOMETHING_UPPERCASE", "UPPERCASE") - .build() - assertThat(request.headers.get("SOMETHING_LOWERCASE").getOrNull(0)).isEqualTo("lowercase") - assertThat(request.headers.get("something_capitalized").getOrNull(0)) - .isEqualTo("Capitalized") - assertThat(request.headers.get("Something_Uppercase").getOrNull(0)).isEqualTo("UPPERCASE") - } -} diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AccountHolderListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AccountHolderListParamsTest.kt index ecf92949..bcf5c511 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AccountHolderListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AccountHolderListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -42,25 +43,25 @@ class AccountHolderListParamsTest { .phoneNumber("phone_number") .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("email", listOf("email")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("external_id", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("first_name", listOf("first_name")) - expected.put("last_name", listOf("last_name")) - expected.put("legal_business_name", listOf("legal_business_name")) - expected.put("limit", listOf("123")) - expected.put("phone_number", listOf("phone_number")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("email", "email") + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("external_id", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("first_name", "first_name") + expected.put("last_name", "last_name") + expected.put("legal_business_name", "legal_business_name") + expected.put("limit", "123") + expected.put("phone_number", "phone_number") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = AccountHolderListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AccountListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AccountListParamsTest.kt index 70af2d8d..74a1f7a7 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AccountListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AccountListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -30,19 +31,19 @@ class AccountListParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = AccountListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AggregateBalanceListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AggregateBalanceListParamsTest.kt index e8826a41..c3d9c747 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AggregateBalanceListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AggregateBalanceListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -21,18 +22,18 @@ class AggregateBalanceListParamsTest { AggregateBalanceListParams.builder() .financialAccountType(AggregateBalanceListParams.FinancialAccountType.ISSUING) .build() - val expected = mutableMapOf>() + val expected = QueryParams.builder() expected.put( "financial_account_type", - listOf(AggregateBalanceListParams.FinancialAccountType.ISSUING.toString()) + AggregateBalanceListParams.FinancialAccountType.ISSUING.toString() ) - assertThat(params.getQueryParams()).isEqualTo(expected) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = AggregateBalanceListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AuthRuleV2ListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AuthRuleV2ListParamsTest.kt index 20ded119..6c77f16c 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AuthRuleV2ListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/AuthRuleV2ListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -29,19 +30,19 @@ class AuthRuleV2ListParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("card_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("card_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = AuthRuleV2ListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/BalanceListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/BalanceListParamsTest.kt index 884e9def..d3f6154a 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/BalanceListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/BalanceListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -26,20 +27,20 @@ class BalanceListParamsTest { .balanceDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .financialAccountType(BalanceListParams.FinancialAccountType.ISSUING) .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("balance_date", listOf("2019-12-27T18:11:19.117Z")) + val expected = QueryParams.builder() + expected.put("account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("balance_date", "2019-12-27T18:11:19.117Z") expected.put( "financial_account_type", - listOf(BalanceListParams.FinancialAccountType.ISSUING.toString()) + BalanceListParams.FinancialAccountType.ISSUING.toString() ) - assertThat(params.getQueryParams()).isEqualTo(expected) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = BalanceListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/BookTransferListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/BookTransferListParamsTest.kt index b839bc7a..34806500 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/BookTransferListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/BookTransferListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -42,28 +43,25 @@ class BookTransferListParamsTest { .startingAfter("starting_after") .status(BookTransferListParams.Status.DECLINED) .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("business_account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put( - "category", - listOf(BookTransferListParams.Category.BALANCE_OR_FUNDING.toString()) - ) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("financial_account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("page_size", listOf("100")) - expected.put("result", listOf(BookTransferListParams.Result.APPROVED.toString())) - expected.put("starting_after", listOf("starting_after")) - expected.put("status", listOf(BookTransferListParams.Status.DECLINED.toString())) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("business_account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("category", BookTransferListParams.Category.BALANCE_OR_FUNDING.toString()) + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("financial_account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("page_size", "100") + expected.put("result", BookTransferListParams.Result.APPROVED.toString()) + expected.put("starting_after", "starting_after") + expected.put("status", BookTransferListParams.Status.DECLINED.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = BookTransferListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardAggregateBalanceListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardAggregateBalanceListParamsTest.kt index f326d979..0c162aa7 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardAggregateBalanceListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardAggregateBalanceListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -23,16 +24,16 @@ class CardAggregateBalanceListParamsTest { .accountToken("account_token") .businessAccountToken("business_account_token") .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("account_token")) - expected.put("business_account_token", listOf("business_account_token")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("account_token", "account_token") + expected.put("business_account_token", "business_account_token") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = CardAggregateBalanceListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardBalanceListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardBalanceListParamsTest.kt index 9d198ce8..33e93e02 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardBalanceListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardBalanceListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -26,10 +27,10 @@ class CardBalanceListParamsTest { .balanceDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .lastTransactionEventToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .build() - val expected = mutableMapOf>() - expected.put("balance_date", listOf("2019-12-27T18:11:19.117Z")) - expected.put("last_transaction_event_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("balance_date", "2019-12-27T18:11:19.117Z") + expected.put("last_transaction_event_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -38,8 +39,8 @@ class CardBalanceListParamsTest { CardBalanceListParams.builder() .cardToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardEmbedParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardEmbedParamsTest.kt index e9eac923..d8bb45f7 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardEmbedParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardEmbedParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -16,18 +17,18 @@ class CardEmbedParamsTest { @Test fun getQueryParams() { val params = CardEmbedParams.builder().embedRequest("embed_request").hmac("hmac").build() - val expected = mutableMapOf>() - expected.put("embed_request", listOf("embed_request")) - expected.put("hmac", listOf("hmac")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("embed_request", "embed_request") + expected.put("hmac", "hmac") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = CardEmbedParams.builder().embedRequest("embed_request").hmac("hmac").build() - val expected = mutableMapOf>() - expected.put("embed_request", listOf("embed_request")) - expected.put("hmac", listOf("hmac")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("embed_request", "embed_request") + expected.put("hmac", "hmac") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardFinancialTransactionListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardFinancialTransactionListParamsTest.kt index 6f219735..25a0a214 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardFinancialTransactionListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardFinancialTransactionListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -36,24 +37,15 @@ class CardFinancialTransactionListParamsTest { .startingAfter("starting_after") .status(CardFinancialTransactionListParams.Status.DECLINED) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put( - "category", - listOf(CardFinancialTransactionListParams.Category.CARD.toString()) - ) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put( - "result", - listOf(CardFinancialTransactionListParams.Result.APPROVED.toString()) - ) - expected.put("starting_after", listOf("starting_after")) - expected.put( - "status", - listOf(CardFinancialTransactionListParams.Status.DECLINED.toString()) - ) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("category", CardFinancialTransactionListParams.Category.CARD.toString()) + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("result", CardFinancialTransactionListParams.Result.APPROVED.toString()) + expected.put("starting_after", "starting_after") + expected.put("status", CardFinancialTransactionListParams.Status.DECLINED.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -62,8 +54,8 @@ class CardFinancialTransactionListParamsTest { CardFinancialTransactionListParams.builder() .cardToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardListParamsTest.kt index c2f91e3e..34294320 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -34,21 +35,21 @@ class CardListParamsTest { .startingAfter("starting_after") .state(CardListParams.State.CLOSED) .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - expected.put("state", listOf(CardListParams.State.CLOSED.toString())) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + expected.put("state", CardListParams.State.CLOSED.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = CardListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardProgramListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardProgramListParamsTest.kt index 8dbf596d..18b996a5 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardProgramListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/CardProgramListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -25,17 +26,17 @@ class CardProgramListParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = CardProgramListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DigitalCardArtListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DigitalCardArtListParamsTest.kt index 7e26b0be..42fad158 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DigitalCardArtListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DigitalCardArtListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -25,17 +26,17 @@ class DigitalCardArtListParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = DigitalCardArtListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DisputeListEvidencesParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DisputeListEvidencesParamsTest.kt index f7707cf1..7917d30d 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DisputeListEvidencesParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DisputeListEvidencesParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -32,13 +33,13 @@ class DisputeListEvidencesParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -47,8 +48,8 @@ class DisputeListEvidencesParamsTest { DisputeListEvidencesParams.builder() .disputeToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DisputeListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DisputeListParamsTest.kt index 4e85745b..96bc1507 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DisputeListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/DisputeListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -34,21 +35,21 @@ class DisputeListParamsTest { .status(DisputeListParams.Status.ARBITRATION) .transactionTokens(listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - expected.put("status", listOf(DisputeListParams.Status.ARBITRATION.toString())) - expected.put("transaction_tokens", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + expected.put("status", DisputeListParams.Status.ARBITRATION.toString()) + expected.put("transaction_tokens", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = DisputeListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventListAttemptsParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventListAttemptsParamsTest.kt index 0116f723..43369d1a 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventListAttemptsParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventListAttemptsParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -34,21 +35,21 @@ class EventListAttemptsParamsTest { .startingAfter("starting_after") .status(EventListAttemptsParams.Status.FAILED) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - expected.put("status", listOf(EventListAttemptsParams.Status.FAILED.toString())) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + expected.put("status", EventListAttemptsParams.Status.FAILED.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = EventListAttemptsParams.builder().eventToken("event_token").build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventListParamsTest.kt index 0b42a758..2d064fa1 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -34,24 +35,21 @@ class EventListParamsTest { .startingAfter("starting_after") .withContent(true) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put( - "event_types", - listOf(EventListParams.EventType.ACCOUNT_HOLDER_CREATED.toString()) - ) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - expected.put("with_content", listOf("true")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("event_types", EventListParams.EventType.ACCOUNT_HOLDER_CREATED.toString()) + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + expected.put("with_content", "true") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = EventListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionListAttemptsParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionListAttemptsParamsTest.kt index 7e2043b9..c0f1fb35 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionListAttemptsParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionListAttemptsParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -34,14 +35,14 @@ class EventSubscriptionListAttemptsParamsTest { .startingAfter("starting_after") .status(EventSubscriptionListAttemptsParams.Status.FAILED) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - expected.put("status", listOf(EventSubscriptionListAttemptsParams.Status.FAILED.toString())) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + expected.put("status", EventSubscriptionListAttemptsParams.Status.FAILED.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -50,8 +51,8 @@ class EventSubscriptionListAttemptsParamsTest { EventSubscriptionListAttemptsParams.builder() .eventSubscriptionToken("event_subscription_token") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionListParamsTest.kt index 85dd0392..8f63d841 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -25,17 +26,17 @@ class EventSubscriptionListParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = EventSubscriptionListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionRecoverParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionRecoverParamsTest.kt index ac4577d8..0aac2fd3 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionRecoverParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionRecoverParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -26,10 +27,10 @@ class EventSubscriptionRecoverParamsTest { .begin(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .end(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("end", "2019-12-27T18:11:19.117Z") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -38,8 +39,8 @@ class EventSubscriptionRecoverParamsTest { EventSubscriptionRecoverParams.builder() .eventSubscriptionToken("event_subscription_token") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionReplayMissingParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionReplayMissingParamsTest.kt index 6b307b25..7fbb3a9e 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionReplayMissingParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionReplayMissingParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -26,10 +27,10 @@ class EventSubscriptionReplayMissingParamsTest { .begin(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .end(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("end", "2019-12-27T18:11:19.117Z") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -38,8 +39,8 @@ class EventSubscriptionReplayMissingParamsTest { EventSubscriptionReplayMissingParams.builder() .eventSubscriptionToken("event_subscription_token") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ExternalBankAccountListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ExternalBankAccountListParamsTest.kt index c9fbb9e9..1e6b1cab 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ExternalBankAccountListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ExternalBankAccountListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -37,32 +38,26 @@ class ExternalBankAccountListParamsTest { .states(listOf(ExternalBankAccountListParams.AccountState.ENABLED)) .verificationStates(listOf(ExternalBankAccountListParams.VerificationState.PENDING)) .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put( - "account_types", - listOf(ExternalBankAccountListParams.AccountType.CHECKING.toString()) - ) - expected.put("countries", listOf("string")) - expected.put("ending_before", listOf("ending_before")) - expected.put("owner_types", listOf(OwnerType.INDIVIDUAL.toString())) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - expected.put( - "states", - listOf(ExternalBankAccountListParams.AccountState.ENABLED.toString()) - ) + val expected = QueryParams.builder() + expected.put("account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("account_types", ExternalBankAccountListParams.AccountType.CHECKING.toString()) + expected.put("countries", "string") + expected.put("ending_before", "ending_before") + expected.put("owner_types", OwnerType.INDIVIDUAL.toString()) + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + expected.put("states", ExternalBankAccountListParams.AccountState.ENABLED.toString()) expected.put( "verification_states", - listOf(ExternalBankAccountListParams.VerificationState.PENDING.toString()) + ExternalBankAccountListParams.VerificationState.PENDING.toString() ) - assertThat(params.getQueryParams()).isEqualTo(expected) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = ExternalBankAccountListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ExternalPaymentListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ExternalPaymentListParamsTest.kt index 711ea928..66618af9 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ExternalPaymentListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ExternalPaymentListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -40,33 +41,27 @@ class ExternalPaymentListParamsTest { .startingAfter("starting_after") .status(ExternalPaymentListParams.TransactionStatus.PENDING) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("business_account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("business_account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") expected.put( "category", - listOf(ExternalPaymentListParams.ExternalPaymentCategory.EXTERNAL_WIRE.toString()) + ExternalPaymentListParams.ExternalPaymentCategory.EXTERNAL_WIRE.toString() ) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("financial_account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("page_size", listOf("100")) - expected.put( - "result", - listOf(ExternalPaymentListParams.TransactionResult.APPROVED.toString()) - ) - expected.put("starting_after", listOf("starting_after")) - expected.put( - "status", - listOf(ExternalPaymentListParams.TransactionStatus.PENDING.toString()) - ) - assertThat(params.getQueryParams()).isEqualTo(expected) + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("financial_account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("page_size", "100") + expected.put("result", ExternalPaymentListParams.TransactionResult.APPROVED.toString()) + expected.put("starting_after", "starting_after") + expected.put("status", ExternalPaymentListParams.TransactionStatus.PENDING.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = ExternalPaymentListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountBalanceListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountBalanceListParamsTest.kt index 0f0bc60c..a2799527 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountBalanceListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountBalanceListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -26,10 +27,10 @@ class FinancialAccountBalanceListParamsTest { .balanceDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .lastTransactionEventToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .build() - val expected = mutableMapOf>() - expected.put("balance_date", listOf("2019-12-27T18:11:19.117Z")) - expected.put("last_transaction_event_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("balance_date", "2019-12-27T18:11:19.117Z") + expected.put("last_transaction_event_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -38,8 +39,8 @@ class FinancialAccountBalanceListParamsTest { FinancialAccountBalanceListParams.builder() .financialAccountToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountListParamsTest.kt index 65107181..a2b7d9a6 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -25,17 +26,17 @@ class FinancialAccountListParamsTest { .businessAccountToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .type(FinancialAccountListParams.Type.ISSUING) .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("business_account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("type", listOf(FinancialAccountListParams.Type.ISSUING.toString())) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("business_account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("type", FinancialAccountListParams.Type.ISSUING.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = FinancialAccountListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountLoanTapeListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountLoanTapeListParamsTest.kt index 15691571..6bf04db3 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountLoanTapeListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountLoanTapeListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.LocalDate import org.assertj.core.api.Assertions.assertThat @@ -32,13 +33,13 @@ class FinancialAccountLoanTapeListParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27")) - expected.put("end", listOf("2019-12-27")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27") + expected.put("end", "2019-12-27") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -47,8 +48,8 @@ class FinancialAccountLoanTapeListParamsTest { FinancialAccountLoanTapeListParams.builder() .financialAccountToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountStatementLineItemListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountStatementLineItemListParamsTest.kt index 13346dbd..64e50afe 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountStatementLineItemListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountStatementLineItemListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -29,11 +30,11 @@ class FinancialAccountStatementLineItemListParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -43,8 +44,8 @@ class FinancialAccountStatementLineItemListParamsTest { .financialAccountToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .statementToken("statement_token") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountStatementListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountStatementListParamsTest.kt index f49d7abb..250ff99e 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountStatementListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialAccountStatementListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.LocalDate import org.assertj.core.api.Assertions.assertThat @@ -34,14 +35,14 @@ class FinancialAccountStatementListParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27")) - expected.put("end", listOf("2019-12-27")) - expected.put("ending_before", listOf("ending_before")) - expected.put("include_initial_statements", listOf("true")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27") + expected.put("end", "2019-12-27") + expected.put("ending_before", "ending_before") + expected.put("include_initial_statements", "true") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -50,8 +51,8 @@ class FinancialAccountStatementListParamsTest { FinancialAccountStatementListParams.builder() .financialAccountToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialTransactionListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialTransactionListParamsTest.kt index 849d60b3..cf4caa39 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialTransactionListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/FinancialTransactionListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -36,15 +37,15 @@ class FinancialTransactionListParamsTest { .startingAfter("starting_after") .status(FinancialTransactionListParams.Status.DECLINED) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("category", listOf(FinancialTransactionListParams.Category.ACH.toString())) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("result", listOf(FinancialTransactionListParams.Result.APPROVED.toString())) - expected.put("starting_after", listOf("starting_after")) - expected.put("status", listOf(FinancialTransactionListParams.Status.DECLINED.toString())) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("category", FinancialTransactionListParams.Category.ACH.toString()) + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("result", FinancialTransactionListParams.Result.APPROVED.toString()) + expected.put("starting_after", "starting_after") + expected.put("status", FinancialTransactionListParams.Status.DECLINED.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -53,8 +54,8 @@ class FinancialTransactionListParamsTest { FinancialTransactionListParams.builder() .financialAccountToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ManagementOperationListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ManagementOperationListParamsTest.kt index 7c230eac..3326a592 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ManagementOperationListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ManagementOperationListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -38,31 +39,26 @@ class ManagementOperationListParamsTest { .startingAfter("starting_after") .status(ManagementOperationListParams.TransactionStatus.PENDING) .build() - val expected = mutableMapOf>() - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("business_account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) + val expected = QueryParams.builder() + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("business_account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") expected.put( "category", - listOf( - ManagementOperationListParams.ManagementOperationCategory.MANAGEMENT_FEE.toString() - ) + ManagementOperationListParams.ManagementOperationCategory.MANAGEMENT_FEE.toString() ) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("financial_account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - expected.put( - "status", - listOf(ManagementOperationListParams.TransactionStatus.PENDING.toString()) - ) - assertThat(params.getQueryParams()).isEqualTo(expected) + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("financial_account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + expected.put("status", ManagementOperationListParams.TransactionStatus.PENDING.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = ManagementOperationListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/PaymentListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/PaymentListParamsTest.kt index f128fcb5..a4ba1bcf 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/PaymentListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/PaymentListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -42,25 +43,25 @@ class PaymentListParamsTest { .startingAfter("starting_after") .status(PaymentListParams.Status.DECLINED) .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("business_account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("category", listOf(PaymentListParams.Category.ACH.toString())) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("financial_account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("page_size", listOf("100")) - expected.put("result", listOf(PaymentListParams.Result.APPROVED.toString())) - expected.put("starting_after", listOf("starting_after")) - expected.put("status", listOf(PaymentListParams.Status.DECLINED.toString())) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("business_account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("category", PaymentListParams.Category.ACH.toString()) + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("financial_account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("page_size", "100") + expected.put("result", PaymentListParams.Result.APPROVED.toString()) + expected.put("starting_after", "starting_after") + expected.put("status", PaymentListParams.Status.DECLINED.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = PaymentListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ReportSettlementListDetailsParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ReportSettlementListDetailsParamsTest.kt index c8f794f7..523efb75 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ReportSettlementListDetailsParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ReportSettlementListDetailsParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.LocalDate import org.assertj.core.api.Assertions.assertThat @@ -28,11 +29,11 @@ class ReportSettlementListDetailsParamsTest { .pageSize(100L) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -41,8 +42,8 @@ class ReportSettlementListDetailsParamsTest { ReportSettlementListDetailsParams.builder() .reportDate(LocalDate.parse("2019-12-27")) .build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ResponderEndpointCheckStatusParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ResponderEndpointCheckStatusParamsTest.kt index fa0a26a7..c43450ef 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ResponderEndpointCheckStatusParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ResponderEndpointCheckStatusParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -21,12 +22,9 @@ class ResponderEndpointCheckStatusParamsTest { ResponderEndpointCheckStatusParams.builder() .type(ResponderEndpointCheckStatusParams.Type.AUTH_STREAM_ACCESS) .build() - val expected = mutableMapOf>() - expected.put( - "type", - listOf(ResponderEndpointCheckStatusParams.Type.AUTH_STREAM_ACCESS.toString()) - ) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("type", ResponderEndpointCheckStatusParams.Type.AUTH_STREAM_ACCESS.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -35,11 +33,8 @@ class ResponderEndpointCheckStatusParamsTest { ResponderEndpointCheckStatusParams.builder() .type(ResponderEndpointCheckStatusParams.Type.AUTH_STREAM_ACCESS) .build() - val expected = mutableMapOf>() - expected.put( - "type", - listOf(ResponderEndpointCheckStatusParams.Type.AUTH_STREAM_ACCESS.toString()) - ) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("type", ResponderEndpointCheckStatusParams.Type.AUTH_STREAM_ACCESS.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ResponderEndpointDeleteParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ResponderEndpointDeleteParamsTest.kt index 71806c02..0664dd24 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ResponderEndpointDeleteParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/ResponderEndpointDeleteParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test @@ -21,12 +22,9 @@ class ResponderEndpointDeleteParamsTest { ResponderEndpointDeleteParams.builder() .type(ResponderEndpointDeleteParams.Type.AUTH_STREAM_ACCESS) .build() - val expected = mutableMapOf>() - expected.put( - "type", - listOf(ResponderEndpointDeleteParams.Type.AUTH_STREAM_ACCESS.toString()) - ) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("type", ResponderEndpointDeleteParams.Type.AUTH_STREAM_ACCESS.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test @@ -35,11 +33,8 @@ class ResponderEndpointDeleteParamsTest { ResponderEndpointDeleteParams.builder() .type(ResponderEndpointDeleteParams.Type.AUTH_STREAM_ACCESS) .build() - val expected = mutableMapOf>() - expected.put( - "type", - listOf(ResponderEndpointDeleteParams.Type.AUTH_STREAM_ACCESS.toString()) - ) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("type", ResponderEndpointDeleteParams.Type.AUTH_STREAM_ACCESS.toString()) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/TokenizationListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/TokenizationListParamsTest.kt index 5c9e8eeb..e163e9e7 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/TokenizationListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/TokenizationListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.LocalDate import org.assertj.core.api.Assertions.assertThat @@ -36,25 +37,25 @@ class TokenizationListParamsTest { .startingAfter("starting_after") .tokenizationChannel(TokenizationListParams.TokenizationChannel.DIGITAL_WALLET) .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("begin", listOf("2019-12-27")) - expected.put("card_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("end", listOf("2019-12-27")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("starting_after", listOf("starting_after")) + val expected = QueryParams.builder() + expected.put("account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("begin", "2019-12-27") + expected.put("card_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("end", "2019-12-27") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("starting_after", "starting_after") expected.put( "tokenization_channel", - listOf(TokenizationListParams.TokenizationChannel.DIGITAL_WALLET.toString()) + TokenizationListParams.TokenizationChannel.DIGITAL_WALLET.toString() ) - assertThat(params.getQueryParams()).isEqualTo(expected) + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = TokenizationListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/TransactionListParamsTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/TransactionListParamsTest.kt index 308e2e61..81a7e1fa 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/TransactionListParamsTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/models/TransactionListParamsTest.kt @@ -2,6 +2,7 @@ package com.lithic.api.models +import com.lithic.api.core.http.QueryParams import com.lithic.api.models.* import java.time.OffsetDateTime import org.assertj.core.api.Assertions.assertThat @@ -36,22 +37,22 @@ class TransactionListParamsTest { .result(TransactionListParams.Result.APPROVED) .startingAfter("starting_after") .build() - val expected = mutableMapOf>() - expected.put("account_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("begin", listOf("2019-12-27T18:11:19.117Z")) - expected.put("card_token", listOf("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")) - expected.put("end", listOf("2019-12-27T18:11:19.117Z")) - expected.put("ending_before", listOf("ending_before")) - expected.put("page_size", listOf("100")) - expected.put("result", listOf(TransactionListParams.Result.APPROVED.toString())) - expected.put("starting_after", listOf("starting_after")) - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + expected.put("account_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("begin", "2019-12-27T18:11:19.117Z") + expected.put("card_token", "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + expected.put("end", "2019-12-27T18:11:19.117Z") + expected.put("ending_before", "ending_before") + expected.put("page_size", "100") + expected.put("result", TransactionListParams.Result.APPROVED.toString()) + expected.put("starting_after", "starting_after") + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } @Test fun getQueryParamsWithoutOptionalFields() { val params = TransactionListParams.builder().build() - val expected = mutableMapOf>() - assertThat(params.getQueryParams()).isEqualTo(expected) + val expected = QueryParams.builder() + assertThat(params.getQueryParams()).isEqualTo(expected.build()) } } diff --git a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/services/ErrorHandlingTest.kt b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/services/ErrorHandlingTest.kt index 78ac4a93..1cba16c7 100644 --- a/lithic-kotlin-core/src/test/kotlin/com/lithic/api/services/ErrorHandlingTest.kt +++ b/lithic-kotlin-core/src/test/kotlin/com/lithic/api/services/ErrorHandlingTest.kt @@ -7,15 +7,15 @@ import com.github.tomakehurst.wiremock.client.WireMock.anyUrl import com.github.tomakehurst.wiremock.client.WireMock.get import com.github.tomakehurst.wiremock.client.WireMock.ok import com.github.tomakehurst.wiremock.client.WireMock.post +import com.github.tomakehurst.wiremock.client.WireMock.put import com.github.tomakehurst.wiremock.client.WireMock.status import com.github.tomakehurst.wiremock.client.WireMock.stubFor import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo import com.github.tomakehurst.wiremock.junit5.WireMockTest -import com.google.common.collect.ImmutableListMultimap -import com.google.common.collect.ListMultimap import com.lithic.api.client.LithicClient import com.lithic.api.client.okhttp.LithicOkHttpClient import com.lithic.api.core.JsonString +import com.lithic.api.core.http.Headers import com.lithic.api.core.jsonMapper import com.lithic.api.errors.BadRequestException import com.lithic.api.errors.InternalServerException @@ -178,7 +178,7 @@ class ErrorHandlingTest { assertThatThrownBy({ client.cards().create(params) }) .satisfies({ e -> - assertBadRequest(e, ImmutableListMultimap.of("Foo", "Bar"), LITHIC_ERROR) + assertBadRequest(e, Headers.builder().put("Foo", "Bar").build(), LITHIC_ERROR) }) } @@ -226,7 +226,7 @@ class ErrorHandlingTest { assertThatThrownBy({ client.cards().create(params) }) .satisfies({ e -> - assertUnauthorized(e, ImmutableListMultimap.of("Foo", "Bar"), LITHIC_ERROR) + assertUnauthorized(e, Headers.builder().put("Foo", "Bar").build(), LITHIC_ERROR) }) } @@ -274,7 +274,7 @@ class ErrorHandlingTest { assertThatThrownBy({ client.cards().create(params) }) .satisfies({ e -> - assertPermissionDenied(e, ImmutableListMultimap.of("Foo", "Bar"), LITHIC_ERROR) + assertPermissionDenied(e, Headers.builder().put("Foo", "Bar").build(), LITHIC_ERROR) }) } @@ -322,7 +322,7 @@ class ErrorHandlingTest { assertThatThrownBy({ client.cards().create(params) }) .satisfies({ e -> - assertNotFound(e, ImmutableListMultimap.of("Foo", "Bar"), LITHIC_ERROR) + assertNotFound(e, Headers.builder().put("Foo", "Bar").build(), LITHIC_ERROR) }) } @@ -370,7 +370,11 @@ class ErrorHandlingTest { assertThatThrownBy({ client.cards().create(params) }) .satisfies({ e -> - assertUnprocessableEntity(e, ImmutableListMultimap.of("Foo", "Bar"), LITHIC_ERROR) + assertUnprocessableEntity( + e, + Headers.builder().put("Foo", "Bar").build(), + LITHIC_ERROR + ) }) } @@ -418,7 +422,7 @@ class ErrorHandlingTest { assertThatThrownBy({ client.cards().create(params) }) .satisfies({ e -> - assertRateLimit(e, ImmutableListMultimap.of("Foo", "Bar"), LITHIC_ERROR) + assertRateLimit(e, Headers.builder().put("Foo", "Bar").build(), LITHIC_ERROR) }) } @@ -466,7 +470,7 @@ class ErrorHandlingTest { assertThatThrownBy({ client.cards().create(params) }) .satisfies({ e -> - assertInternalServer(e, ImmutableListMultimap.of("Foo", "Bar"), LITHIC_ERROR) + assertInternalServer(e, Headers.builder().put("Foo", "Bar").build(), LITHIC_ERROR) }) } @@ -517,7 +521,7 @@ class ErrorHandlingTest { assertUnexpectedStatusCodeException( e, 999, - ImmutableListMultimap.of("Foo", "Bar"), + Headers.builder().put("Foo", "Bar").build(), toJson(LITHIC_ERROR) ) }) @@ -611,7 +615,7 @@ class ErrorHandlingTest { assertThatThrownBy({ client.cards().create(params) }) .satisfies({ e -> - assertBadRequest(e, ImmutableListMultimap.of(), LithicError.builder().build()) + assertBadRequest(e, Headers.builder().build(), LithicError.builder().build()) }) } @@ -622,7 +626,7 @@ class ErrorHandlingTest { private fun assertUnexpectedStatusCodeException( throwable: Throwable, statusCode: Int, - headers: ListMultimap, + headers: Headers, responseBody: ByteArray ) { assertThat(throwable) @@ -632,43 +636,31 @@ class ErrorHandlingTest { .satisfies({ e -> assertThat(e.statusCode()).isEqualTo(statusCode) assertThat(e.body()).isEqualTo(String(responseBody)) - assertThat(e.headers()).containsAllEntriesOf(headers) + assertThat(e.headers().toMap()).containsAllEntriesOf(headers.toMap()) }) } - private fun assertBadRequest( - throwable: Throwable, - headers: ListMultimap, - error: LithicError - ) { + private fun assertBadRequest(throwable: Throwable, headers: Headers, error: LithicError) { assertThat(throwable) .asInstanceOf(InstanceOfAssertFactories.throwable(BadRequestException::class.java)) .satisfies({ e -> assertThat(e.statusCode()).isEqualTo(400) assertThat(e.error()).isEqualTo(error) - assertThat(e.headers()).containsAllEntriesOf(headers) + assertThat(e.headers().toMap()).containsAllEntriesOf(headers.toMap()) }) } - private fun assertUnauthorized( - throwable: Throwable, - headers: ListMultimap, - error: LithicError - ) { + private fun assertUnauthorized(throwable: Throwable, headers: Headers, error: LithicError) { assertThat(throwable) .asInstanceOf(InstanceOfAssertFactories.throwable(UnauthorizedException::class.java)) .satisfies({ e -> assertThat(e.statusCode()).isEqualTo(401) assertThat(e.error()).isEqualTo(error) - assertThat(e.headers()).containsAllEntriesOf(headers) + assertThat(e.headers().toMap()).containsAllEntriesOf(headers.toMap()) }) } - private fun assertPermissionDenied( - throwable: Throwable, - headers: ListMultimap, - error: LithicError - ) { + private fun assertPermissionDenied(throwable: Throwable, headers: Headers, error: LithicError) { assertThat(throwable) .asInstanceOf( InstanceOfAssertFactories.throwable(PermissionDeniedException::class.java) @@ -676,27 +668,23 @@ class ErrorHandlingTest { .satisfies({ e -> assertThat(e.statusCode()).isEqualTo(403) assertThat(e.error()).isEqualTo(error) - assertThat(e.headers()).containsAllEntriesOf(headers) + assertThat(e.headers().toMap()).containsAllEntriesOf(headers.toMap()) }) } - private fun assertNotFound( - throwable: Throwable, - headers: ListMultimap, - error: LithicError - ) { + private fun assertNotFound(throwable: Throwable, headers: Headers, error: LithicError) { assertThat(throwable) .asInstanceOf(InstanceOfAssertFactories.throwable(NotFoundException::class.java)) .satisfies({ e -> assertThat(e.statusCode()).isEqualTo(404) assertThat(e.error()).isEqualTo(error) - assertThat(e.headers()).containsAllEntriesOf(headers) + assertThat(e.headers().toMap()).containsAllEntriesOf(headers.toMap()) }) } private fun assertUnprocessableEntity( throwable: Throwable, - headers: ListMultimap, + headers: Headers, error: LithicError ) { assertThat(throwable) @@ -706,35 +694,32 @@ class ErrorHandlingTest { .satisfies({ e -> assertThat(e.statusCode()).isEqualTo(422) assertThat(e.error()).isEqualTo(error) - assertThat(e.headers()).containsAllEntriesOf(headers) + assertThat(e.headers().toMap()).containsAllEntriesOf(headers.toMap()) }) } - private fun assertRateLimit( - throwable: Throwable, - headers: ListMultimap, - error: LithicError - ) { + private fun assertRateLimit(throwable: Throwable, headers: Headers, error: LithicError) { assertThat(throwable) .asInstanceOf(InstanceOfAssertFactories.throwable(RateLimitException::class.java)) .satisfies({ e -> assertThat(e.statusCode()).isEqualTo(429) assertThat(e.error()).isEqualTo(error) - assertThat(e.headers()).containsAllEntriesOf(headers) + assertThat(e.headers().toMap()).containsAllEntriesOf(headers.toMap()) }) } - private fun assertInternalServer( - throwable: Throwable, - headers: ListMultimap, - error: LithicError - ) { + private fun assertInternalServer(throwable: Throwable, headers: Headers, error: LithicError) { assertThat(throwable) .asInstanceOf(InstanceOfAssertFactories.throwable(InternalServerException::class.java)) .satisfies({ e -> assertThat(e.statusCode()).isEqualTo(500) assertThat(e.error()).isEqualTo(error) - assertThat(e.headers()).containsAllEntriesOf(headers) + assertThat(e.headers().toMap()).containsAllEntriesOf(headers.toMap()) }) } + + private fun Headers.toMap(): Map> = + mutableMapOf>().also { map -> + names().forEach { map[it] = values(it) } + } }