@attocash/commons-js 5.0.0

package/ktor-ktor-client-core/io/ktor/client/plugins/HttpCallValidator.mjs

@@ -0,0 +1,916 @@
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import {
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { PipelineContext34fsb0mycu471 as PipelineContext } from '../../../../../ktor-ktor-utils/io/ktor/util/pipeline/PipelineContext.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Phases_getInstance3gwf7ca9zp4r6 as Phases_getInstance } from '../request/HttpRequestPipeline.mjs';
+import {
+  isSuspendFunction153vlp5l2npj9 as isSuspendFunction,
+  isInterface3d6p8outrmvmk as isInterface,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import {
+  HttpResponseContainer3r9yzy4mwwvc9 as HttpResponseContainer,
+  Phases_getInstance3cv4l5wlctlnh as Phases_getInstance_0,
+} from '../statement/HttpResponsePipeline.mjs';
+import { PipelinePhase2q3d54imxjlma as PipelinePhase } from '../../../../../ktor-ktor-utils/io/ktor/util/pipeline/PipelinePhase.mjs';
+import { reversed22y3au42jl32b as reversed } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import {
+  SetupRequest_instance16261rb0s0wyp as SetupRequest_instance,
+  Send_instance19u839hbvwh8q as Send_instance,
+  Sender1wtdgti85uk42 as Sender,
+} from './api/CommonHooks.mjs';
+import {
+  HttpRequestBuilder15f2nnx9sjuv1 as HttpRequestBuilder,
+  HttpRequest3fsc4149kgwfg as HttpRequest,
+  get_coroutineContext1djaai1ellg0c as get_coroutineContext,
+} from '../request/HttpRequest.mjs';
+import { unwrapCancellationException1zvbmufui4i9c as unwrapCancellationException } from '../utils/ExceptionUtils.nonJvm.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  toString1pkumu07cwy4m as toString,
+  protoOf180f3jzyo7rfj as protoOf,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { KtorSimpleLogger1xdphsp5l4e48 as KtorSimpleLogger } from '../../../../../ktor-ktor-utils/io/ktor/util/logging/KtorSimpleLoggerJs.mjs';
+import { createClientPluginjwpvufjows5r as createClientPlugin } from './api/CreatePluginUtils.mjs';
+import { PrimitiveClasses_getInstance2v63zn04dtq03 as PrimitiveClasses_getInstance } from '../../../../../kotlin-kotlin-stdlib/kotlin/reflect/js/internal/primitives.mjs';
+import { arrayOf1akklvh2at202 as arrayOf } from '../../../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
+import { createKType1lgox3mzhchp5 as createKType } from '../../../../../kotlin-kotlin-stdlib/KTypeHelpers.mjs';
+import { TypeInfo2nbxsuf4v8os2 as TypeInfo } from '../../../../../ktor-ktor-utils/io/ktor/util/reflect/Type.mjs';
+import { AttributeKey3aq8ytwgx54f7 as AttributeKey } from '../../../../../ktor-ktor-utils/io/ktor/util/Attributes.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_LOGGER() {
+  _init_properties_HttpCallValidator_kt__r6yh2y();
+  return LOGGER;
+}
+var LOGGER;
+function get_HttpCallValidator() {
+  _init_properties_HttpCallValidator_kt__r6yh2y();
+  return HttpCallValidator;
+}
+var HttpCallValidator;
+function get_ExpectSuccessAttributeKey() {
+  _init_properties_HttpCallValidator_kt__r6yh2y();
+  return ExpectSuccessAttributeKey;
+}
+var ExpectSuccessAttributeKey;
+var HttpCallValidatorConfigClass;
+function HttpCallValidatorConfig() {
+  if (HttpCallValidatorConfigClass === VOID) {
+    class $ {
+      constructor() {
+        var tmp = this;
+        // Inline function 'kotlin.collections.mutableListOf' call
+        tmp.q5c_1 = ArrayList().l1();
+        var tmp_0 = this;
+        // Inline function 'kotlin.collections.mutableListOf' call
+        tmp_0.r5c_1 = ArrayList().l1();
+        this.s5c_1 = true;
+      }
+      t5c(block) {
+        // Inline function 'kotlin.collections.plusAssign' call
+        this.q5c_1.m(block);
+      }
+    }
+    initMetadataForClass($, 'HttpCallValidatorConfig', HttpCallValidatorConfig);
+    HttpCallValidatorConfigClass = $;
+  }
+  return HttpCallValidatorConfigClass;
+}
+var ExceptionHandlerWrapperClass;
+function ExceptionHandlerWrapper() {
+  if (ExceptionHandlerWrapperClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'ExceptionHandlerWrapper');
+    ExceptionHandlerWrapperClass = $;
+  }
+  return ExceptionHandlerWrapperClass;
+}
+var RequestExceptionHandlerWrapperClass;
+function RequestExceptionHandlerWrapper() {
+  if (RequestExceptionHandlerWrapperClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'RequestExceptionHandlerWrapper');
+    RequestExceptionHandlerWrapperClass = $;
+  }
+  return RequestExceptionHandlerWrapperClass;
+}
+var RequestError$install$slambdaClass;
+function RequestError$install$slambda() {
+  if (RequestError$install$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($handler, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.n5f_1 = $handler;
+        super(resultContinuation, $box);
+      }
+      s4y($this$intercept, it, $completion) {
+        var tmp = this.t4y($this$intercept, it, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      ld(p1, p2, $completion) {
+        var tmp = p1 instanceof PipelineContext() ? p1 : THROW_CCE();
+        return this.s4y(tmp, !(p2 == null) ? p2 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 5;
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = this.o5f_1.k3v(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                this.q5f_1 = suspendResult;
+                this.bc_1 = 5;
+                this.ac_1 = 4;
+                continue $sm;
+              case 2:
+                this.bc_1 = 5;
+                var tmp_0 = this.dc_1;
+                if (tmp_0 instanceof Error) {
+                  this.r5f_1 = this.dc_1;
+                  this.ac_1 = 3;
+                  suspendResult = this.n5f_1(HttpRequest_0(this.o5f_1.h3w_1), this.r5f_1, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 3:
+                var error = suspendResult;
+                var tmp_1 = this;
+                if (!(error == null))
+                  throw error;
+                tmp_1.q5f_1 = Unit_instance;
+                this.ac_1 = 4;
+                continue $sm;
+              case 4:
+                this.bc_1 = 5;
+                return Unit_instance;
+              case 5:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 5) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      t4y($this$intercept, it, completion) {
+        var i = new (RequestError$install$slambda())(this.n5f_1, completion);
+        i.o5f_1 = $this$intercept;
+        i.p5f_1 = it;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [2]);
+    RequestError$install$slambdaClass = $;
+  }
+  return RequestError$install$slambdaClass;
+}
+function RequestError$install$slambda_0($handler, resultContinuation) {
+  var i = new (RequestError$install$slambda())($handler, resultContinuation);
+  var l = function ($this$intercept, it, $completion) {
+    return i.s4y($this$intercept, it, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+var RequestErrorClass;
+function RequestError() {
+  if (RequestErrorClass === VOID) {
+    class $ {
+      s5f(client, handler) {
+        var tmp = Phases_getInstance().u58_1;
+        client.y4x_1.l3w(tmp, RequestError$install$slambda_0(handler, null));
+      }
+      z58(client, handler) {
+        return this.s5f(client, (!(handler == null) ? isSuspendFunction(handler, 2) : false) ? handler : THROW_CCE());
+      }
+    }
+    initMetadataForObject($, 'RequestError');
+    RequestErrorClass = $;
+  }
+  return RequestErrorClass;
+}
+var RequestError_instance;
+function RequestError_getInstance() {
+  return RequestError_instance;
+}
+var ReceiveError$install$slambdaClass;
+function ReceiveError$install$slambda() {
+  if (ReceiveError$install$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($handler, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.b5g_1 = $handler;
+        super(resultContinuation, $box);
+      }
+      n4z($this$intercept, it, $completion) {
+        var tmp = this.o4z($this$intercept, it, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      ld(p1, p2, $completion) {
+        var tmp = p1 instanceof PipelineContext() ? p1 : THROW_CCE();
+        return this.n4z(tmp, p2 instanceof HttpResponseContainer() ? p2 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 5;
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = this.c5g_1.k3v(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                this.e5g_1 = suspendResult;
+                this.bc_1 = 5;
+                this.ac_1 = 4;
+                continue $sm;
+              case 2:
+                this.bc_1 = 5;
+                var tmp_0 = this.dc_1;
+                if (tmp_0 instanceof Error) {
+                  this.f5g_1 = this.dc_1;
+                  this.ac_1 = 3;
+                  suspendResult = this.b5g_1(this.c5g_1.h3w_1.q51(), this.f5g_1, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 3:
+                var error = suspendResult;
+                var tmp_1 = this;
+                if (!(error == null))
+                  throw error;
+                tmp_1.e5g_1 = Unit_instance;
+                this.ac_1 = 4;
+                continue $sm;
+              case 4:
+                this.bc_1 = 5;
+                return Unit_instance;
+              case 5:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 5) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      o4z($this$intercept, it, completion) {
+        var i = new (ReceiveError$install$slambda())(this.b5g_1, completion);
+        i.c5g_1 = $this$intercept;
+        i.d5g_1 = it;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [2]);
+    ReceiveError$install$slambdaClass = $;
+  }
+  return ReceiveError$install$slambdaClass;
+}
+function ReceiveError$install$slambda_0($handler, resultContinuation) {
+  var i = new (ReceiveError$install$slambda())($handler, resultContinuation);
+  var l = function ($this$intercept, it, $completion) {
+    return i.n4z($this$intercept, it, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+var ReceiveErrorClass;
+function ReceiveError() {
+  if (ReceiveErrorClass === VOID) {
+    class $ {
+      s5f(client, handler) {
+        var BeforeReceive = new (PipelinePhase())('BeforeReceive');
+        client.z4x_1.k3w(Phases_getInstance_0().y50_1, BeforeReceive);
+        client.z4x_1.l3w(BeforeReceive, ReceiveError$install$slambda_0(handler, null));
+      }
+      z58(client, handler) {
+        return this.s5f(client, (!(handler == null) ? isSuspendFunction(handler, 2) : false) ? handler : THROW_CCE());
+      }
+    }
+    initMetadataForObject($, 'ReceiveError');
+    ReceiveErrorClass = $;
+  }
+  return ReceiveErrorClass;
+}
+var ReceiveError_instance;
+function ReceiveError_getInstance() {
+  return ReceiveError_instance;
+}
+function HttpRequest_0(builder) {
+  _init_properties_HttpCallValidator_kt__r6yh2y();
+  return new (HttpRequest$1())(builder);
+}
+function HttpResponseValidator(_this__u8e3s4, block) {
+  _init_properties_HttpCallValidator_kt__r6yh2y();
+  _this__u8e3s4.i51(get_HttpCallValidator(), block);
+}
+function HttpCallValidatorConfig$_init_$ref_m1o2g9() {
+  var l = function () {
+    return new (HttpCallValidatorConfig())();
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function HttpCallValidator$lambda($this$createClientPlugin) {
+  _init_properties_HttpCallValidator_kt__r6yh2y();
+  var responseValidators = reversed($this$createClientPlugin.u59_1.q5c_1);
+  var callExceptionHandlers = reversed($this$createClientPlugin.u59_1.r5c_1);
+  var expectSuccess = $this$createClientPlugin.u59_1.s5c_1;
+  var tmp = SetupRequest_instance;
+  $this$createClientPlugin.x59(tmp, HttpCallValidator$lambda$slambda_0(expectSuccess, null));
+  var tmp_0 = Send_instance;
+  $this$createClientPlugin.x59(tmp_0, HttpCallValidator$lambda$slambda_2(responseValidators, null));
+  var tmp_1 = RequestError_instance;
+  $this$createClientPlugin.x59(tmp_1, HttpCallValidator$lambda$slambda_4(callExceptionHandlers, null));
+  var tmp_2 = ReceiveError_instance;
+  $this$createClientPlugin.x59(tmp_2, HttpCallValidator$lambda$slambda_6(callExceptionHandlers, null));
+  return Unit_instance;
+}
+function invoke$validateResponse(responseValidators, response, $completion) {
+  var tmp = new ($invoke$validateResponseCOROUTINE$())(responseValidators, response, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function invoke$processException(callExceptionHandlers, cause, request, $completion) {
+  var tmp = new ($invoke$processExceptionCOROUTINE$())(callExceptionHandlers, cause, request, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function HttpCallValidator$lambda$slambda$lambda($expectSuccess) {
+  return function () {
+    return $expectSuccess;
+  };
+}
+var HttpCallValidator$lambda$slambdaClass;
+function HttpCallValidator$lambda$slambda() {
+  if (HttpCallValidator$lambda$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($expectSuccess, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.w5h_1 = $expectSuccess;
+        super(resultContinuation, $box);
+      }
+      y5h(request, $completion) {
+        var tmp = this.z5h(request, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.y5h(p1 instanceof HttpRequestBuilder() ? p1 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            if (tmp === 0) {
+              this.bc_1 = 1;
+              var tmp_0 = get_ExpectSuccessAttributeKey();
+              this.x5h_1.e50_1.i3r(tmp_0, HttpCallValidator$lambda$slambda$lambda(this.w5h_1));
+              return Unit_instance;
+            } else if (tmp === 1) {
+              throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            throw e;
+          }
+         while (true);
+      }
+      z5h(request, completion) {
+        var i = new (HttpCallValidator$lambda$slambda())(this.w5h_1, completion);
+        i.x5h_1 = request;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    HttpCallValidator$lambda$slambdaClass = $;
+  }
+  return HttpCallValidator$lambda$slambdaClass;
+}
+function HttpCallValidator$lambda$slambda_0($expectSuccess, resultContinuation) {
+  var i = new (HttpCallValidator$lambda$slambda())($expectSuccess, resultContinuation);
+  var l = function (request, $completion) {
+    return i.y5h(request, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var HttpCallValidator$lambda$slambdaClass_0;
+function HttpCallValidator$lambda$slambda_1() {
+  if (HttpCallValidator$lambda$slambdaClass_0 === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($responseValidators, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.i5i_1 = $responseValidators;
+        super(resultContinuation, $box);
+      }
+      m5i($this$on, request, $completion) {
+        var tmp = this.n5i($this$on, request, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      ld(p1, p2, $completion) {
+        var tmp = p1 instanceof Sender() ? p1 : THROW_CCE();
+        return this.m5i(tmp, p2 instanceof HttpRequestBuilder() ? p2 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 3;
+                this.ac_1 = 1;
+                suspendResult = this.j5i_1.q5i(this.k5i_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                this.l5i_1 = suspendResult;
+                this.ac_1 = 2;
+                suspendResult = invoke$validateResponse(this.i5i_1, this.l5i_1.z4y(), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                return this.l5i_1;
+              case 3:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 3) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      n5i($this$on, request, completion) {
+        var i = new (HttpCallValidator$lambda$slambda_1())(this.i5i_1, completion);
+        i.j5i_1 = $this$on;
+        i.k5i_1 = request;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [2]);
+    HttpCallValidator$lambda$slambdaClass_0 = $;
+  }
+  return HttpCallValidator$lambda$slambdaClass_0;
+}
+function HttpCallValidator$lambda$slambda_2($responseValidators, resultContinuation) {
+  var i = new (HttpCallValidator$lambda$slambda_1())($responseValidators, resultContinuation);
+  var l = function ($this$on, request, $completion) {
+    return i.m5i($this$on, request, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+var HttpCallValidator$lambda$slambdaClass_1;
+function HttpCallValidator$lambda$slambda_3() {
+  if (HttpCallValidator$lambda$slambdaClass_1 === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($callExceptionHandlers, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.z5i_1 = $callExceptionHandlers;
+        super(resultContinuation, $box);
+      }
+      d5j(request, cause, $completion) {
+        var tmp = this.e5j(request, cause, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      ld(p1, p2, $completion) {
+        var tmp = (!(p1 == null) ? isInterface(p1, HttpRequest()) : false) ? p1 : THROW_CCE();
+        return this.d5j(tmp, p2 instanceof Error ? p2 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.c5j_1 = unwrapCancellationException(this.b5j_1);
+                this.ac_1 = 1;
+                suspendResult = invoke$processException(this.z5i_1, this.c5j_1, this.a5j_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return this.c5j_1;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      e5j(request, cause, completion) {
+        var i = new (HttpCallValidator$lambda$slambda_3())(this.z5i_1, completion);
+        i.a5j_1 = request;
+        i.b5j_1 = cause;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [2]);
+    HttpCallValidator$lambda$slambdaClass_1 = $;
+  }
+  return HttpCallValidator$lambda$slambdaClass_1;
+}
+function HttpCallValidator$lambda$slambda_4($callExceptionHandlers, resultContinuation) {
+  var i = new (HttpCallValidator$lambda$slambda_3())($callExceptionHandlers, resultContinuation);
+  var l = function (request, cause, $completion) {
+    return i.d5j(request, cause, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+var HttpCallValidator$lambda$slambdaClass_2;
+function HttpCallValidator$lambda$slambda_5() {
+  if (HttpCallValidator$lambda$slambdaClass_2 === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($callExceptionHandlers, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.n5j_1 = $callExceptionHandlers;
+        super(resultContinuation, $box);
+      }
+      d5j(request, cause, $completion) {
+        var tmp = this.e5j(request, cause, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      ld(p1, p2, $completion) {
+        var tmp = (!(p1 == null) ? isInterface(p1, HttpRequest()) : false) ? p1 : THROW_CCE();
+        return this.d5j(tmp, p2 instanceof Error ? p2 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.q5j_1 = unwrapCancellationException(this.p5j_1);
+                this.ac_1 = 1;
+                suspendResult = invoke$processException(this.n5j_1, this.q5j_1, this.o5j_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return this.q5j_1;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      e5j(request, cause, completion) {
+        var i = new (HttpCallValidator$lambda$slambda_5())(this.n5j_1, completion);
+        i.o5j_1 = request;
+        i.p5j_1 = cause;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [2]);
+    HttpCallValidator$lambda$slambdaClass_2 = $;
+  }
+  return HttpCallValidator$lambda$slambdaClass_2;
+}
+function HttpCallValidator$lambda$slambda_6($callExceptionHandlers, resultContinuation) {
+  var i = new (HttpCallValidator$lambda$slambda_5())($callExceptionHandlers, resultContinuation);
+  var l = function (request, cause, $completion) {
+    return i.d5j(request, cause, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+var $invoke$validateResponseCOROUTINE$Class;
+function $invoke$validateResponseCOROUTINE$() {
+  if ($invoke$validateResponseCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(responseValidators, response, resultContinuation) {
+        super(resultContinuation);
+        this.o5g_1 = responseValidators;
+        this.p5g_1 = response;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 4;
+                get_LOGGER().s3x('Validating response for request ' + this.p5g_1.x51().q51().z51().toString());
+                var tmp_0 = this;
+                tmp_0.q5g_1 = this.o5g_1;
+                this.r5g_1 = this.q5g_1;
+                this.s5g_1 = this.r5g_1.d1();
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!this.s5g_1.e1()) {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+                this.t5g_1 = this.s5g_1.f1();
+                var tmp_1 = this;
+                tmp_1.u5g_1 = this.t5g_1;
+                this.v5g_1 = this.u5g_1;
+                this.ac_1 = 2;
+                suspendResult = this.v5g_1(this.p5g_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.ac_1 = 1;
+                continue $sm;
+              case 3:
+                return Unit_instance;
+              case 4:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 4) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $invoke$validateResponseCOROUTINE$Class = $;
+  }
+  return $invoke$validateResponseCOROUTINE$Class;
+}
+var $invoke$processExceptionCOROUTINE$Class;
+function $invoke$processExceptionCOROUTINE$() {
+  if ($invoke$processExceptionCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(callExceptionHandlers, cause, request, resultContinuation) {
+        super(resultContinuation);
+        this.e5h_1 = callExceptionHandlers;
+        this.f5h_1 = cause;
+        this.g5h_1 = request;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 6;
+                get_LOGGER().s3x('Processing exception ' + this.f5h_1.toString() + ' for request ' + this.g5h_1.z51().toString());
+                var tmp_0 = this;
+                tmp_0.h5h_1 = this.e5h_1;
+                this.i5h_1 = this.h5h_1;
+                this.j5h_1 = this.i5h_1.d1();
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!this.j5h_1.e1()) {
+                  this.ac_1 = 5;
+                  continue $sm;
+                }
+
+                this.k5h_1 = this.j5h_1.f1();
+                var tmp_1 = this;
+                tmp_1.l5h_1 = this.k5h_1;
+                this.m5h_1 = this.l5h_1;
+                this.n5h_1 = this.m5h_1;
+                var tmp_2 = this.n5h_1;
+                if (tmp_2 instanceof ExceptionHandlerWrapper()) {
+                  this.ac_1 = 3;
+                  suspendResult = this.m5h_1.s5j_1(this.f5h_1, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  var tmp_3 = this.n5h_1;
+                  if (tmp_3 instanceof RequestExceptionHandlerWrapper()) {
+                    this.ac_1 = 2;
+                    suspendResult = this.m5h_1.r5j_1(this.f5h_1, this.g5h_1, this);
+                    if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                      return suspendResult;
+                    }
+                    continue $sm;
+                  } else {
+                    noWhenBranchMatchedException();
+                  }
+                }
+
+                break;
+              case 2:
+                this.ac_1 = 4;
+                continue $sm;
+              case 3:
+                this.ac_1 = 4;
+                continue $sm;
+              case 4:
+                this.ac_1 = 1;
+                continue $sm;
+              case 5:
+                return Unit_instance;
+              case 6:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 6) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $invoke$processExceptionCOROUTINE$Class = $;
+  }
+  return $invoke$processExceptionCOROUTINE$Class;
+}
+var HttpRequest$1Class;
+function HttpRequest$1() {
+  if (HttpRequest$1Class === VOID) {
+    class $ {
+      constructor($builder) {
+        this.x5j_1 = $builder;
+        this.t5j_1 = $builder.a50_1;
+        this.u5j_1 = $builder.z4z_1.z1i();
+        this.v5j_1 = $builder.e50_1;
+        this.w5j_1 = $builder.b50_1.z1i();
+      }
+      x51() {
+        var message = 'Call is not initialized';
+        throw IllegalStateException().o4(toString(message));
+      }
+      y51() {
+        return this.t5j_1;
+      }
+      z51() {
+        return this.u5j_1;
+      }
+      r51() {
+        return this.v5j_1;
+      }
+      l45() {
+        return this.w5j_1;
+      }
+    }
+    protoOf($).s1x = get_coroutineContext;
+    initMetadataForClass($, VOID, VOID, VOID, [HttpRequest()]);
+    HttpRequest$1Class = $;
+  }
+  return HttpRequest$1Class;
+}
+var properties_initialized_HttpCallValidator_kt_xrx49w;
+function _init_properties_HttpCallValidator_kt__r6yh2y() {
+  if (!properties_initialized_HttpCallValidator_kt_xrx49w) {
+    properties_initialized_HttpCallValidator_kt_xrx49w = true;
+    LOGGER = KtorSimpleLogger('io.ktor.client.plugins.HttpCallValidator');
+    var tmp = HttpCallValidatorConfig$_init_$ref_m1o2g9();
+    HttpCallValidator = createClientPlugin('HttpResponseValidator', tmp, HttpCallValidator$lambda);
+    // Inline function 'io.ktor.util.AttributeKey' call
+    var name = 'ExpectSuccessAttributeKey';
+    // Inline function 'io.ktor.util.reflect.typeInfo' call
+    var tmp_0 = PrimitiveClasses_getInstance().zg();
+    // Inline function 'io.ktor.util.reflect.typeOfOrNull' call
+    var tmp_1;
+    try {
+      tmp_1 = createKType(PrimitiveClasses_getInstance().zg(), arrayOf([]), false);
+    } catch ($p) {
+      var tmp_2;
+      if ($p instanceof Error) {
+        var _unused_var__etf5q3 = $p;
+        tmp_2 = null;
+      } else {
+        throw $p;
+      }
+      tmp_1 = tmp_2;
+    }
+    var tmp$ret$0 = tmp_1;
+    var tmp$ret$1 = new (TypeInfo())(tmp_0, tmp$ret$0);
+    ExpectSuccessAttributeKey = new (AttributeKey())(name, tmp$ret$1);
+  }
+}
+//region block: init
+RequestError_instance = new (RequestError())();
+ReceiveError_instance = new (ReceiveError())();
+//endregion
+//region block: exports
+export {
+  get_ExpectSuccessAttributeKey as get_ExpectSuccessAttributeKey20jj5fup38v1g,
+  get_HttpCallValidator as get_HttpCallValidator3iji36qylbtbr,
+  HttpResponseValidator as HttpResponseValidator2d6ie1tmzg8fi,
+};
+//endregion
+
+//# sourceMappingURL=HttpCallValidator.mjs.map