* @return the PAC logon information
     */
    public PacLogonInfo getLogonInfo() {
        return this.logonInfo;
    }

    /**
     * Returns the PAC credential type information.
     * @return the PAC credential type
     */
    public PacCredentialType getCredentialType() {
        return this.credentialType;
    }

    /**
     * Returns the server signature used to validate PAC integrity.

    /** SID name type: domain. */
    public static final int SID_NAME_DOMAIN = 3;
    /** SID name type: alias. */
    /** SID name type: alias. */
    public static final int SID_NAME_ALIAS = 4;
    /** SID name type: well-known group. */
    /** SID name type: well-known group. */
    public static final int SID_NAME_WKN_GRP = 5;
    /** SID name type: deleted. */
    /** SID name type: deleted account. */

  /**
   * Sets the default value for {@code type}, when dummy value for a parameter of the same type
   * needs to be created in order to invoke a method or constructor. The default value isn't used in
   * testing {@link Object#equals} because more than one sample instances are needed for testing
   * inequality.
   */
  protected final <T> void setDefault(Class<T> type, T value) {
    tester.setDefault(type, value);
  }

  /**

				recvType := decl.Recv.List[0].Type
				if recvType != nil {
					t := recvType
					if star, ok := unparen(t).(*ast.StarExpr); ok {
						t = star.X
					}
					if sel, ok := unparen(t).(*ast.SelectorExpr); ok {
						var buf strings.Builder
						format.Node(&buf, fset, recvType)
						error_(sel.Pos(), `cannot define new methods on non-local type %s`, &buf)
					}
				}
			}
		}

	}

        assertEquals(0, share1.type, "Share 1 raw type should be 0.");
        assertEquals("Remark 1", share1.remark.trim(), "Share 1 remark should be correct.");

        SmbShareInfo share2 = (SmbShareInfo) response.results[1];
        assertEquals("IPC$", share2.getName().trim(), "Share 2 name should be correct.");
        assertEquals(3, share2.type, "Share 2 raw type should be 3.");

     *
     * @param sid the RPC sid_t structure
     * @param type the SID type
     * @param domainName the domain name for this SID
     * @param acctName the account name for this SID
     * @param decrementAuthority whether to decrement the authority count
     */
    public SID(final rpc.sid_t sid, final int type, final String domainName, final String acctName, final boolean decrementAuthority) {

            SmbNamedPipe pipe = new SmbNamedPipe(url, SmbPipeResource.PIPE_TYPE_RDWR, ctx());

            // Assert: type is named pipe and pipe type preserved
            assertEquals(SmbConstants.TYPE_NAMED_PIPE, pipe.getType(), "Type should be TYPE_NAMED_PIPE");
            assertEquals(SmbPipeResource.PIPE_TYPE_RDWR, pipe.getPipeType(), "Pipe type should match constructor");
        }

        @ParameterizedTest

  val rangeStart: Int

  data class Constant(
    override val rangeStart: Int,
    val type: Int,
  ) : MappedRange {
    val b1: Int
      get() =
        when (type) {
          TYPE_IGNORED -> 119
          TYPE_VALID -> 120
          TYPE_DISALLOWED -> 121
          else -> error("unexpected type: $type")
        }
  }

  data class Inline1(
    override val rangeStart: Int,

                return authenticator.getLoginCredential();
            }
        }
        return null;
    }

    /**
     * Gets the appropriate response for the specified SSO response type.
     *
     * @param responseType The type of SSO response required (e.g., METADATA, LOGOUT)
     * @return The action response from the SSO authenticator, or null if SSO is not available
     */

      "crawling_info_param" : {
        "properties" : {
          "crawlingInfoId" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "key" : {
            "type" : "keyword"
          },
          "value" : {
            "type" : "keyword"
          }
        }
      }
    },
    "settings" : {
      "index" : {