"type": "keyword"
      },
      "errorLog": {
        "type": "keyword"
      },
      "errorCount": {
        "type": "integer"
      },
      "lastAccessTime": {
        "type": "long"
      },
      "configId": {
        "type": "keyword"
      }
    }

   *
   * @since 14.0
   */
  public static UnsignedInteger fromIntBits(int bits) {
    return new UnsignedInteger(bits);
  }

  /**
   * Returns an {@code UnsignedInteger} that is equal to {@code value}, if possible. The inverse
   * operation of {@link #longValue()}.
   */
  public static UnsignedInteger valueOf(long value) {
    checkArgument(

) {
  private var lastId: String? = null

  interface Callback {
    fun onEvent(
      id: String?,
      type: String?,
      data: String,
    )

    fun onRetryChange(timeMs: Long)
  }

  /**
   * Process the next event. This will result in a single call to [Callback.onEvent] *unless* the
   * data section was empty. Any number of calls to [Callback.onRetryChange] may occur while

                      public InputStream openStream() {
                        return new ByteArrayInputStream(newPreFilledByteArray(0, 50)) {
                          @Override
                          public long skip(long n) {
                            return 0;
                          }
                        };
                      }
                    })
                .iterator());

    @JvmName("create")
    fun BufferedSource.asResponseBody(
      contentType: MediaType? = null,
      contentLength: Long = -1L,
    ): ResponseBody =
      object : ResponseBody() {
        override fun contentType(): MediaType? = contentType

        override fun contentLength(): Long = contentLength

        override fun source(): BufferedSource = this@asResponseBody
      }

    @JvmStatic

    /*
     * Padding from 40 into 64 bytes, same size as cache line. Might be beneficial to add a fourth
     * long here, to minimize chance of interference between consecutive locks, but I couldn't
     * observe any benefit from that.
     */
    long unused1;
    long unused2;
    long unused3;

    PaddedLock() {
      super(false);
    }
  }

    String threadName = Finalizer.class.getName();
    Thread thread = null;
    if (bigThreadConstructor != null) {
      try {
        boolean inheritThreadLocals = false;
        long defaultStackSize = 0;
        thread =
            bigThreadConstructor.newInstance(
                (ThreadGroup) null, finalizer, threadName, defaultStackSize, inheritThreadLocals);
      } catch (Throwable t) {

            configMockedStatic.close();
    }

    @Test
    void testCacheEntry() {
        // Test with a specific TTL
        long ttl = 600; // 10 minutes
        Dfs.CacheEntry cacheEntry = new Dfs.CacheEntry(ttl);
        long expectedExpiration = System.currentTimeMillis() + ttl * 1000L;
        assertTrue(cacheEntry.expiration >= expectedExpiration - 100 && cacheEntry.expiration <= expectedExpiration + 100);

        return this;
    }

    public void setGidNumber_Equal(Long gidNumber) {
        setGidNumber_Term(gidNumber, null);
    }

    public void setGidNumber_Equal(Long gidNumber, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setGidNumber_Term(gidNumber, opLambda);
    }

    public void setGidNumber_Term(Long gidNumber) {
        setGidNumber_Term(gidNumber, null);
    }

 */
public class SsoLoginException extends FessSystemException {

    /** Serial version UID for serialization compatibility. */
    private static final long serialVersionUID = 1L;

    /**
     * Constructs a new SsoLoginException with the specified detail message.
     *
     * @param message The detail message explaining the SSO login failure
     */