}

    public void setName_Equal(String name) {
        setName_Term(name, null);
    }

    public void setName_Equal(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setName_Term(name, opLambda);
    }

    public void setName_Term(String name) {
        setName_Term(name, null);
    }

    public void setName_Term(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {

    private static final Logger log = LoggerFactory.getLogger(EnumTest.class);


    /**
     * @param name
     * @param properties
     */
    public EnumTest ( String name, Map<String, String> properties ) {
        super(name, properties);
    }


    @Parameters ( name = "{0}" )
    public static Collection<Object> configs () {

        return (introducedDependencyArtifacts != null) ? introducedDependencyArtifacts : Collections.emptySet();
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDescription() {

  }

  private fun registerStandardClass(
    access: Feature.BeforeAnalysisAccess,
    name: String,
  ) {
    val clazz: Class<*> = access.findClassByName(name) ?: throw IllegalStateException("Missing class $name")
    RuntimeReflection.register(clazz)
    clazz.declaredConstructors.forEach {
      RuntimeReflection.register(it)
    }
  }

staticClients:
  - id: example-app
    redirectURIs:
      - 'http://localhost:8080/oauth2/callback'
    name: 'Example App'
    secret: ZXhhbXBsZS1hcHAtc2VjcmV0

connectors:
  - type: mockCallback
    id: mock
    name: Example

# Let dex keep a list of passwords which can be used to login to dex.
enablePasswordDB: true

	if err != nil {
		t.Fatalf("Failed to initialize KMS: %v", err)
	}

	key, err := KMS.GenerateKey(context.Background(), &GenerateKeyRequest{Name: "my-key"})
	if err != nil {
		t.Fatalf("Failed to generate key: %v", err)
	}
	plaintext, err := KMS.Decrypt(context.TODO(), &DecryptRequest{
		Name:       key.KeyID,
		Ciphertext: key.Ciphertext,
	})
	if err != nil {
		t.Fatalf("Failed to decrypt key: %v", err)
	}

  // Registers a function with this context, after this the function is
  // available to be called/referenced by its name in this context.
  virtual absl::Status RegisterFunction(AbstractFunction*) = 0;
  // Remove a function. 'func' argument is the name of a previously added
  // FunctionDef. The name is in fdef.signature.name.
  virtual absl::Status RemoveFunction(const string& func) = 0;

 private:
  const AbstractContextKind kind_;
};

    }

    public void add(final String name, final QueryCommand queryCommand) {
        if (name == null || queryCommand == null) {
            throw new IllegalArgumentException("name or queryCommand is null.");
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded {}", name);
        }
        queryCommandMap.put(name, queryCommand);
    }

	"http://dbflute.org/meta/lastadi10.dtd">
<components>
	<include path="fess_config.xml"/>

	<component name="webApiManagerFactory" class="org.codelibs.fess.api.WebApiManagerFactory">
	</component>

	<component name="searchApiManager" class="org.codelibs.fess.api.json.SearchApiManager">
	</component>
	<component name="searchEngineApiManager" class="org.codelibs.fess.api.engine.SearchEngineApiManager">
	</component>

from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: Optional[str] = None


app = FastAPI(separate_input_output_schemas=False)


@app.post("/items/")
def create_item(item: Item):
    return item


@app.get("/items/")
def read_items() -> list[Item]:
    return [
        Item(
            name="Portal Gun",