.build();
    }

    @Nonnull
    static ToolchainsBuilderRequestBuilder builder() {
        return new ToolchainsBuilderRequestBuilder();
    }

    @NotThreadSafe
    class ToolchainsBuilderRequestBuilder {
        ProtoSession session;
        RequestTrace trace;
        Source installationToolchainsSource;
        Source userToolchainsSource;

from pydantic import BaseModel, SecretStr
from pydantic_settings import BaseSettings


class Settings(BaseSettings):
    github_repository: str
    github_token: SecretStr
    deploy_url: str | None = None
    commit_sha: str
    run_id: int
    state: Literal["pending", "success", "error"] = "pending"


class LinkData(BaseModel):
    previous_link: str
    preview_link: str
    en_link: str | None = None

import javassist.bytecode.annotation.StringMemberValue
import org.gradle.api.reflect.TypeOf
import org.gradle.kotlin.dsl.*


internal
val CtClass.isKotlin: Boolean
    get() = hasAnnotation(Metadata::class.qualifiedName)


internal
val CtMethod.isSynthetic
    get() = methodInfo.getAttribute(SyntheticAttribute.tag) != null


internal
val MemberValue.intValue: Int
    get() {
        var value: Int? = null

import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.Size;

/**
 * The create form for Scheduler.
 *
 */
public class CreateForm {

    /**
     * Creates a new CreateForm instance.
     */
    public CreateForm() {
    }

    /**
     * The CRUD mode for the form.
     */
    @ValidateTypeFailure

import org.lastaflute.web.validation.Required;

import jakarta.validation.constraints.Size;

/**
 * Form class for handling "go" requests that redirect users to specific documents
 * or search results. This form captures the necessary parameters for document
 * access tracking and error page fallback information.
 *
 */
public class GoForm {

    /**
     * Default constructor for GoForm.
     */
    public GoForm() {

 */

package jcifs.smb1.dcerpc;

/**
 * A Unicode string representation for DCE/RPC operations in JCIFS.
 * This class wraps strings for use in RPC calls with optional zero termination.
 */
public class UnicodeString extends rpc.unicode_string {

    boolean zterm;

    /**
     * Constructs a UnicodeString with zero termination option.
     *

 */

package jcifs.smb;

import java.util.Arrays;

import jcifs.BufferCache;
import jcifs.Configuration;

/**
 * Cache for reusable byte buffers
 *
 *
 * <p>This class is intended for internal use.</p>
 */
public class BufferCacheImpl implements BufferCache {

    private final Object[] cache;
    private final int bufferSize;
    private int freeBuffers = 0;

    /**

package jcifs.internal.smb2.lock;

import jcifs.Encodable;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Lock data structure.
 *
 * This class represents a single lock element used in
 * SMB2 Lock requests for byte-range locking.
 *
 * @author mbechler
 */
public class Smb2Lock implements Encodable {

    /**
     * Flag indicating a shared lock that allows concurrent read access.
     */

     *
     * @param <T> the target type to unwrap to
     * @param type the class of the target type
     * @return the referral adapted to type
     * @throws ClassCastException
     *             if the type is not valid for this object
     */
    <T extends DfsReferralData> T unwrap(Class<T> type);

    /**
     * Get the server this referral points to
     *

 * as desired per the <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator
 * pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingBlockingQueue}.
 *