discordpy - en to ja_JP translation catalogue (200 entries)

en: Commands
ja_JP: コマンド

en: One of the most appealing aspects of the command extension is how easy it is to define commands and how you can arbitrarily nest groups and commands to have a rich sub-command system.
ja_JP: コマンド拡張の最も魅力的な機能の一つは、簡単にコマンドが定義でき、かつそのコマンドを好きなようにネスト状にして、豊富なサブコマンドを用意することができる点です。

en: Commands are defined by attaching it to a regular Python function. The command is then invoked by the user using a similar signature to the Python function.
ja_JP: コマンドは、Pythonの関数と関連付けすることによって定義され、同様のシグネチャを使用してユーザーに呼び出されます。

en: You must have access to the :attr:`~discord.Intents.message_content` intent for the commands extension to function. This must be set both in the developer portal and within your code.
ja_JP: コマンド拡張機能が機能するには、 :attr:`~discord.Intents.message_content` インテントが必要です。これは、デベロッパーポータルとコード内の両方で有効化しないといけません。

en: Failure to do this will result in your bot not responding to any of your commands.
ja_JP: そうしない場合は、ボットはコマンドに応答しなくなります。

en: For example, in the given command definition:
ja_JP: 例えば、次のコマンド定義を使うと次のようになります。

en: With the following prefix (``$``), it would be invoked by the user via:
ja_JP: 接頭辞を (``$``) としたとすると、このコマンドは次のように実行できます。

en: A command must always have at least one parameter, ``ctx``, which is the :class:`.Context` as the first one.
ja_JP: コマンドには、少なくとも :class:`.Context` を渡すための引数 ``ctx`` が必要です。

en: There are two ways of registering a command. The first one is by using :meth:`.Bot.command` decorator, as seen in the example above. The second is using the :func:`~ext.commands.command` decorator followed by :meth:`.Bot.add_command` on the instance.
ja_JP: コマンドを登録するには二通りの方法があります。一つ目は :meth:`.Bot.command` を使用する方法で、二つ目が :func:`~ext.commands.command` デコレータを使用して :meth:`.Bot.add_command` でインスタンスにコマンドを追加していく方法です。

en: Essentially, these two are equivalent: ::
ja_JP: 本質的に、これら2つは同等になります: ::

en: Since the :meth:`.Bot.command` decorator is shorter and easier to comprehend, it will be the one used throughout the documentation here.
ja_JP: :meth:`.Bot.command` が簡単かつ理解がしやすいので、ドキュメント上ではこちらを使っています。

en: Any parameter that is accepted by the :class:`~discord.ext.commands.Command` constructor can be passed into the decorator. For example, to change the name to something other than the function would be as simple as doing this:
ja_JP: :class:`~discord.ext.commands.Command` のコンストラクタの引数はデコレータに渡すことで利用できます。例えば、コマンドの名前を関数以外のものへと変更したい場合は以下のように簡単に設定することができます。

en: Parameters
ja_JP: パラメータ

en: Since we define commands by making Python functions, we also define the argument passing behaviour by the function parameters.
ja_JP: Pythonの関数定義によって、同時にコマンドを定義するので、関数のパラメータを設定することにより、コマンドの引数受け渡し動作も定義することができます。

en: Certain parameter types do different things in the user side and most forms of parameter types are supported.
ja_JP: 特定のパラメータタイプはユーザーサイドで異なる動作を行い、そしてほとんどの形式のパラメータタイプがサポートされています。

en: Positional
ja_JP: 位置パラメータ

en: The most basic form of parameter passing is the positional parameter. This is where we pass a parameter as-is:
ja_JP: 最も基本的な引数は位置パラメータです。与えられた値をそのまま渡します。

en: On the bot using side, you can provide positional arguments by just passing a regular string:
ja_JP: Botの使用者側は、通常の文字列を渡すだけで位置パラメータに値を渡すことができます。

en: To make use of a word with spaces in between, you should quote it:
ja_JP: 間に空白を含む文字列を渡す場合は、文字列を引用符で囲む必要があります。

en: As a note of warning, if you omit the quotes, you will only get the first word:
ja_JP: 引用符を用いなかった場合、最初の文字列のみが渡されます。

en: Since positional arguments are just regular Python arguments, you can have as many as you want:
ja_JP: 位置パラメータは、Pythonの引数と同じものなので、好きなだけ設定することが可能です。

en: Variable
ja_JP: 可変長引数

en: Sometimes you want users to pass in an undetermined number of parameters. The library supports this similar to how variable list parameters are done in Python:
ja_JP: 場合によっては、可変長のパラメータを設定したい場合もあるでしょう。このライブラリはPythonの可変長パラメータと同様にこれをサポートしています。

en: This allows our user to accept either one or many arguments as they please. This works similar to positional arguments, so multi-word parameters should be quoted.
ja_JP: これによって一つ、あるいは複数の引数を受け取ることができます。ただし、引数を渡す際の挙動は位置パラメータと同様のため、複数の単語を含む文字列は引用符で囲む必要があります。

en: For example, on the bot side:
ja_JP: 例えば、ボット側ではこのように動きます。

en: If the user wants to input a multi-word argument, they have to quote it like earlier:
ja_JP: 複数単語の文字列を渡す際は、引用符で囲んでください。

en: Do note that similar to the Python function behaviour, a user can technically pass no arguments at all:
ja_JP: Pythonの振る舞いと同様に、ユーザーは引数なしの状態を渡すことも一応できます。

en: Since the ``args`` variable is a :class:`py:tuple`, you can do anything you would usually do with one.
ja_JP: ``args`` 変数は :class:`py:tuple` となるため、通常のタプルと同様の操作が行なえます。

en: Keyword-Only Arguments
ja_JP: キーワード引数

en: When you want to handle parsing of the argument yourself or do not feel like you want to wrap multi-word user input into quotes, you can ask the library to give you the rest as a single argument. We do this by using a **keyword-only argument**, seen below:
ja_JP: 引数の構文解析を自分で行う場合や、複数単語の入力を引用符で囲む必要のないようにしたい場合は、渡された値を単一の引数として受け取るようにライブラリに求めることができます。以下のコードのようにキーワード引数のみを使用することでこれが可能になります。

en: You can only have one keyword-only argument due to parsing ambiguities.
ja_JP: 解析が曖昧になるため、キーワード引数は一つまでしか扱えません。

en: On the bot side, we do not need to quote input with spaces:
ja_JP: ボット側では、スペースを含む入力を引用符で囲む必要がありません:

en: Do keep in mind that wrapping it in quotes leaves it as-is:
ja_JP: 引用符で囲んだ場合、消えずに残るので注意してください:

en: By default, the keyword-only arguments are stripped of white space to make it easier to work with. This behaviour can be toggled by the :attr:`.Command.rest_is_raw` argument in the decorator.
ja_JP: 通常、キーワード引数は利便性のために空白文字で分割されます。この動作はデコレータの引数として :attr:`.Command.rest_is_raw` を使うことで切り替えることが可能です。

en: Invocation Context
ja_JP: 呼び出しコンテキスト

en: As seen earlier, every command must take at least a single parameter, called the :class:`~ext.commands.Context`.
ja_JP: 前述の通り、すべてのコマンドは必ず :class:`~ext.commands.Context` と呼ばれるパラメータを受け取らなければいけません。

en: This parameter gives you access to something called the "invocation context". Essentially all the information you need to know how the command was executed. It contains a lot of useful information:
ja_JP: このパラメータにより、「呼び出しコンテキスト」というものにアクセスできます。言うなればコマンドがどのように実行されたのかを知るのに必要な基本的情報です。これにはたくさんの有用な情報が含まれています。

en: :attr:`.Context.guild` returns the :class:`Guild` of the command, if any.
ja_JP: 存在する場合、:attr:`.Context.guild` は、コマンドの :class:`Guild` を返します。

en: :attr:`.Context.message` returns the :class:`Message` of the command.
ja_JP: :attr:`.Context.message` は、コマンドの :class:`Message` を返します。

en: :attr:`.Context.author` returns the :class:`Member` or :class:`User` that called the command.
ja_JP: :attr:`.Context.author` は、 コマンドを呼び出した :class:`Member` または :class:`User` を返します。

en: :meth:`.Context.send` to send a message to the channel the command was used in.
ja_JP: :meth:`.Context.send` で、コマンドが実行されたチャンネルにメッセージを送信できます。

en: The context implements the :class:`abc.Messageable` interface, so anything you can do on a :class:`abc.Messageable` you can do on the :class:`~ext.commands.Context`.
ja_JP: コンテキストは :class:`abc.Messageable` インタフェースを実装しているため、 :class:`abc.Messageable` 上でできることは :class:`~ext.commands.Context` 上でも行うことが可能です。

en: Converters
ja_JP: コンバーター

en: Adding bot arguments with function parameters is only the first step in defining your bot's command interface. To actually make use of the arguments, we usually want to convert the data into a target type. We call these :ref:`ext_commands_api_converters`.
ja_JP: ボットの引数を関数のパラメータとして設定するのは、ボットのコマンドインタフェースを定義する第一歩でしかありません。引数を実際に扱うには、大抵の場合、データを目的の型へとと変換する必要があります。私達はこれを :ref:`ext_commands_api_converters` と呼んでいます。

en: Converters come in a few flavours:
ja_JP: コンバーターにはいくつかの種類があります:

en: A regular callable object that takes an argument as a sole parameter and returns a different type.
ja_JP: 引数を単独のパラメータとして受け取り、異なる型として返す、通常の呼び出し可能オブジェクト。

en: These range from your own function, to something like :class:`bool` or :class:`int`.
ja_JP: これらにはあなたの作った関数、 :class:`bool` や :class:`int` といったものまで含まれます。

en: A custom class that inherits from :class:`~ext.commands.Converter`.
ja_JP: :class:`~ext.commands.Converter` を継承したカスタムクラス。

en: Basic Converters
ja_JP: 基本的なコンバーター

en: At its core, a basic converter is a callable that takes in an argument and turns it into something else.
ja_JP: 基本的なコンバーターは、中核をなすものであり、受け取った引数を別のものへと変換します。

en: For example, if we wanted to add two numbers together, we could request that they are turned into integers for us by specifying the converter:
ja_JP: 例えば、二つの値を加算したい場合、コンバーターを指定することにより、受け取った値を整数型へ変換するように要求できます。

en: We specify converters by using something called a **function annotation**. This is a Python 3 exclusive feature that was introduced in :pep:`3107`.
ja_JP: コンバーターの指定には関数アノテーションというもの用います。これは :pep:`3107` にて追加された Python 3 にのみ実装されている機能です。

en: This works with any callable, such as a function that would convert a string to all upper-case:
ja_JP: これは、文字列をすべて大文字に変換する関数などといった、任意の呼び出し可能関数でも動作します。

en: bool
ja_JP: 論理型

en: Unlike the other basic converters, the :class:`bool` converter is treated slightly different. Instead of casting directly to the :class:`bool` type, which would result in any non-empty argument returning ``True``, it instead evaluates the argument as ``True`` or ``False`` based on its given content:
ja_JP: 他の基本的なコンバーターとは違って、 :class:`bool` のコンバーターは若干扱いが異なります。 :class:`bool` 型に直接キャストして、空でない引数を ``True`` と判断するのではなく、与えられた値に基づいて ``True`` か ``False`` かを評価します。

en: Advanced Converters
ja_JP: 応用的なコンバーター

en: Sometimes a basic converter doesn't have enough information that we need. For example, sometimes we want to get some information from the :class:`Message` that called the command or we want to do some asynchronous processing.
ja_JP: 場合によっては、基本的なコンバーターを動かすのに必要な情報が不足していることがあります。例えば、実行されたコマンドの :class:`Message` から情報を取得したい場合や、非同期処理を行いたい場合です。

en: For this, the library provides the :class:`~ext.commands.Converter` interface. This allows you to have access to the :class:`.Context` and have the callable be asynchronous. Defining a custom converter using this interface requires overriding a single method, :meth:`.Converter.convert`.
ja_JP: そういった用途のために、このライブラリは :class:`~ext.commands.Converter` インタフェースを提供します。これによって :class:`.Context` にアクセスが可能になり、また、呼び出し可能関数を非同期にもできるようになります。このインタフェースを使用して、カスタムコンバーターを定義したい場合は :meth:`.Converter.convert` をオーバーライドしてください。

en: An example converter:
ja_JP: コンバーターの例

en: The converter provided can either be constructed or not. Essentially these two are equivalent:
ja_JP: コンバーターはインスタンス化されていなくても構いません。以下の例の二つのは同じ処理になります。

en: Having the possibility of the converter be constructed allows you to set up some state in the converter's ``__init__`` for fine tuning the converter. An example of this is actually in the library, :class:`~ext.commands.clean_content`.
ja_JP: コンバーターをインスタンス化する可能性がある場合、コンバーターの調整を行うために ``__init__`` で何かしらの状態を設定することが出来ます。この例としてライブラリに実際に存在する :class:`~ext.commands.clean_content` があります。

en: If a converter fails to convert an argument to its designated target type, the :exc:`.BadArgument` exception must be raised.
ja_JP: コンバーターが渡された引数を指定の型に変換できなかった場合は :exc:`.BadArgument` を送出しないといけません。

en: Inline Advanced Converters
ja_JP: 埋込み型の応用的なコンバーター

en: If we don't want to inherit from :class:`~ext.commands.Converter`, we can still provide a converter that has the advanced functionalities of an advanced converter and save us from specifying two types.
ja_JP: :class:`~ext.commands.Converter` を継承したくない場合のために、応用的なコンバーターの高度な機能を備えたコンバーターを提供しています。これを使用することで２つのクラスを作成する必要がなくなります。

en: For example, a common idiom would be to have a class and a converter for that class:
ja_JP: 例えば、一般的な書き方だと、クラスとそのクラスへのコンバーターを定義します:

en: This can get tedious, so an inline advanced converter is possible through a :func:`classmethod` inside the type:
ja_JP: これでは面倒なので、 :func:`classmethod` を使って組み込み型の応用的なコンバーターの実装が可能です。

en: Discord Converters
ja_JP: Discord コンバーター

en: Working with :ref:`discord_api_models` is a fairly common thing when defining commands, as a result the library makes working with them easy.
ja_JP: :ref:`discord_api_models` を使用して作業を行うのは、コマンドを定義する際には一般的なことです。そのため、このライブラリでは簡単に作業が行えるようになっています。

en: For example, to receive a :class:`Member` you can just pass it as a converter:
ja_JP: 例えば、 :class:`Member` を受け取るには、これをコンバーターとして渡すだけです。

en: When this command is executed, it attempts to convert the string given into a :class:`Member` and then passes it as a parameter for the function. This works by checking if the string is a mention, an ID, a nickname, a username + discriminator, or just a regular username. The default set of converters have been written to be as easy to use as possible.
ja_JP: このコマンドが実行されると、与えられた文字列を :class:`Member` に変換して、それを関数のパラメーターとして渡します。これは文字列がメンション、ID、ニックネーム、ユーザー名 + Discordタグ、または普通のユーザー名かどうかをチェックすることで機能しています。デフォルトで定義されているコンバーターは、できるだけ簡単に使えるように作られています。

en: A lot of discord models work out of the gate as a parameter:
ja_JP: Discordモデルの多くがコンバーターとして動作します。

en: :class:`Object` (since v2.0)
ja_JP: :class:`Object` (v2.0から)

en: :class:`Message` (since v1.1)
ja_JP: :class:`Message` (v1.1 から)

en: :class:`PartialMessage` (since v1.7)
ja_JP: :class:`PartialMessage` (v1.7 から)

en: :class:`abc.GuildChannel` (since 2.0)
ja_JP: :class:`abc.GuildChannel` (v2.0から)

en: :class:`StageChannel` (since v1.7)
ja_JP: :class:`StageChannel` (v1.7から)

en: :class:`ForumChannel` (since v2.0)
ja_JP: :class:`ForumChannel` (v2.0から)

en: :class:`Guild` (since v1.7)
ja_JP: :class:`Guild` (v1.7 から)

en: :class:`Thread` (since v2.0)
ja_JP: :class:`Thread` (v2.0から)

en: :class:`GuildSticker` (since v2.0)
ja_JP: :class:`GuildSticker` （v2.0から）

en: :class:`ScheduledEvent` (since v2.0)
ja_JP: :class:`ScheduledEvent` （v2.0から）

en: Having any of these set as the converter will intelligently convert the argument to the appropriate target type you specify.
ja_JP: これらをコンバーターとして設定すると、引数を指定した型へとインテリジェントに変換します。

en: Under the hood, these are implemented by the :ref:`ext_commands_adv_converters` interface. A table of the equivalent converter is given below:
ja_JP: これらは :ref:`ext_commands_adv_converters` インタフェースによって実装されています。コンバーターとクラスの関係は以下の通りです。

en: Discord Class
ja_JP: Discord クラス

en: Converter
ja_JP: コンバーター

en: By providing the converter it allows us to use them as building blocks for another converter:
ja_JP: コンバーターを継承することで、他のコンバーターの一部として使うことができます:

en: Special Converters
ja_JP: 特殊なコンバーター

en: The command extension also has support for certain converters to allow for more advanced and intricate use cases that go beyond the generic linear parsing. These converters allow you to introduce some more relaxed and dynamic grammar to your commands in an easy to use manner.
ja_JP: コマンド拡張機能は一般的な線形解析を超える、より高度で複雑な使用法に対応するため、特殊なコンバーターをサポートしています。これらのコンバーターは、簡単な方法でコマンドに更に容易で動的な文法の導入を可能にします。

en: A :data:`typing.Union` is a special type hint that allows for the command to take in any of the specific types instead of a singular type. For example, given the following:
ja_JP: :data:`typing.Union` はコマンドが単数の型の代わりに、複数の特定の型を取り込める特殊な型ヒントです。例えば:

en: The ``what`` parameter would either take a :class:`discord.TextChannel` converter or a :class:`discord.Member` converter. The way this works is through a left-to-right order. It first attempts to convert the input to a :class:`discord.TextChannel`, and if it fails it tries to convert it to a :class:`discord.Member`. If all converters fail, then a special error is raised, :exc:`~ext.commands.BadUnionArgument`.
ja_JP: ``what`` パラメータには :class:`discord.TextChannel` コンバーターか :class:`discord.Member` コンバーターのいずれかが用いられます。これは左から右の順で変換できるか試行することになります。最初に渡された値を :class:`discord.TextChannel` へ変換しようと試み、失敗した場合は :class:`discord.Member` に変換しようとします。すべてのコンバーターで失敗した場合は :exc:`~ext.commands.BadUnionArgument` というエラーが発生します。

en: Note that any valid converter discussed above can be passed in to the argument list of a :data:`typing.Union`.
ja_JP: 以前に説明した有効なコンバーターは、すべて :data:`typing.Union` にわたすことが可能です。

en: A :data:`typing.Optional` is a special type hint that allows for "back-referencing" behaviour. If the converter fails to parse into the specified type, the parser will skip the parameter and then either ``None`` or the specified default will be passed into the parameter instead. The parser will then continue on to the next parameters and converters, if any.
ja_JP: :data:`typing.Optional` は「後方参照」のような動作をする特殊な型ヒントです。コンバーターが指定された型へのパースに失敗した場合、パーサーは代わりに ``None`` または指定されたデフォルト値をパラメータに渡したあと、そのパラメータをスキップします。次のパラメータまたはコンバータがあれば、そちらに進みます。

en: Consider the following example:
ja_JP: 次の例をみてください:

en: In this example, since the argument could not be converted into an ``int``, the default of ``99`` is passed and the parser resumes handling, which in this case would be to pass it into the ``liquid`` parameter.
ja_JP: この例では引数を ``int`` に変換することができなかったので、デフォルト値である ``99`` を代入し、パーサーは処理を続行しています。この場合、先程の変換に失敗した引数は ``liquid`` パラメータに渡されます。

en: This converter only works in regular positional parameters, not variable parameters or keyword-only parameters.
ja_JP: このコンバーターは位置パラメータでのみ動作し、可変長パラメータやキーワードパラメータでは機能しません。

en: A :data:`typing.Literal` is a special type hint that requires the passed parameter to be equal to one of the listed values after being converted to the same type. For example, given the following:
ja_JP: :data:`typing.Literal` は、渡されたパラメータが同じ型に変換された後にリストされた値のいずれかに等しいことを要求する特別な型ヒントです。 例えば、以下のように指定します。

en: The ``buy_sell`` parameter must be either the literal string ``"buy"`` or ``"sell"`` and ``amount`` must convert to the ``int`` ``1`` or ``2``. If ``buy_sell`` or ``amount`` don't match any value, then a special error is raised, :exc:`~.ext.commands.BadLiteralArgument`. Any literal values can be mixed and matched within the same :data:`typing.Literal` converter.
ja_JP: ``buy_sell`` パラメータはリテラル文字列の ``"buy"`` または ``"sell"`` のどちらかで、 ``amount`` は ``int`` の ``1`` または ``2`` に変換されなければなりません。 ``buy_sell`` または ``amount`` がどの値にも一致しない場合は、特別なエラー :exc:`~.ext.commands.BadLiteralArgument` が発生します。任意のリテラル値は、同じ :data:`typing.Literal` コンバーター内で混合してマッチさせることができます。

en: Note that ``typing.Literal[True]`` and ``typing.Literal[False]`` still follow the :class:`bool` converter rules.
ja_JP: ``typing.Literal[True]`` と ``typing.Literal[False]`` は :class:`bool` コンバーターのルールに従っていることに注意してください。

en: A :data:`typing.Annotated` is a special type introduced in Python 3.9 that allows the type checker to see one type, but allows the library to see another type. This is useful for appeasing the type checker for complicated converters. The second parameter of ``Annotated`` must be the converter that the library should use.
ja_JP: :data:`typing.Annotated` は Python 3.9 で導入された特別な型です。 これを使用すると、型チェッカは1つのタイプを参照できますが、ライブラリは別のタイプを参照できます。 これは複雑なコンバータにて型チェッカを通すのに役立ちます。 ``Annotated`` の2番目のパラメータはライブラリが使用するコンバータでなければなりません。

en: For example, given the following:
ja_JP: 例えば、以下の例では:

en: The type checker will see ``arg`` as a regular :class:`str` but the library will know you wanted to change the input into all upper-case.
ja_JP: 型チェッカは ``arg`` を通常の :class:`str` として認識しますが、ライブラリは入力をすべて大文字に変更したいことを知っています。

en: For Python versions below 3.9, it is recommended to install the ``typing_extensions`` library and import ``Annotated`` from there.
ja_JP: Python 3.9未満では、 ``typing_extensions`` ライブラリをインストールして ``Annotated`` をそこからインポートすることを推奨します。

en: The :class:`~ext.commands.Greedy` converter is a generalisation of the :data:`typing.Optional` converter, except applied to a list of arguments. In simple terms, this means that it tries to convert as much as it can until it can't convert any further.
ja_JP: :class:`~ext.commands.Greedy` コンバーターは引数にリストが適用される以外は :data:`typing.Optional` を一般化したものです。簡単に言うと、与えられた引数を変換ができなくなるまで指定の型に変換しようと試みます。

en: When invoked, it allows for any number of members to be passed in:
ja_JP: これが呼び出されると、任意の数のメンバーを渡すことができます:

en: The type passed when using this converter depends on the parameter type that it is being attached to:
ja_JP: このコンバータを利用した際に渡される型は、その対象となっているパラメータの種類によって異なります。

en: Positional parameter types will receive either the default parameter or a :class:`list` of the converted values.
ja_JP: 位置パラメータの場合、型はデフォルトのものか変換された値からなる :class:`list` になります。

en: Variable parameter types will be a :class:`tuple` as usual.
ja_JP: 可変長パラメータの場合、型は通常同様 :class:`tuple` になります。

en: Keyword-only parameter types will be the same as if :class:`~ext.commands.Greedy` was not passed at all.
ja_JP: キーワードパラメータの場合、型は :class:`~ext.commands.Greedy` を使用していないときと同じになります。

en: :class:`~ext.commands.Greedy` parameters can also be made optional by specifying an optional value.
ja_JP: :class:`~ext.commands.Greedy` パラメータはデフォルト値を指定することでオプションにすることもできます。

en: When mixed with the :data:`typing.Optional` converter you can provide simple and expressive command invocation syntaxes:
ja_JP: :data:`typing.Optional` コンバータと併用することで、シンプルかつ表現に富む呼び出し構文を提供できます。

en: This command can be invoked any of the following ways:
ja_JP: このコマンドは以下のような方法で呼び出すことが可能です。

en: The usage of :class:`~ext.commands.Greedy` and :data:`typing.Optional` are powerful and useful, however as a price, they open you up to some parsing ambiguities that might surprise some people.
ja_JP: :class:`~ext.commands.Greedy` と :data:`typing.Optional` の利用は強力かつ便利である反面、その代償として一部の人が驚いてしまうような曖昧な構文解析を許容することとなります。

en: For example, a signature expecting a :data:`typing.Optional` of a :class:`discord.Member` followed by a :class:`int` could catch a member named after a number due to the different ways a :class:`~ext.commands.MemberConverter` decides to fetch members. You should take care to not introduce unintended parsing ambiguities in your code. One technique would be to clamp down the expected syntaxes allowed through custom converters or reordering the parameters to minimise clashes.
ja_JP: 例えば、 :class:`discord.Member` の :data:`typing.Optional` の後に :class:`int` が続くようなシグネチャでは :class:`~ext.commands.MemberConverter` がメンバー取得のために様々な方法をとることが要因となり、名前が数字になっているメンバーを取得してしまう可能性があります。コードが意図しない曖昧な構文解析を引き起こさないよう注意してください。テクニックの一つとして、カスタムコンバーターを用いて予期される構文の許容を制限するか、このような衝突を最小限に抑えるために、パラメータを並び替えることなどが挙げられます。

en: To help aid with some parsing ambiguities, :class:`str`, ``None``, :data:`typing.Optional` and :class:`~ext.commands.Greedy` are forbidden as parameters for the :class:`~ext.commands.Greedy` converter.
ja_JP: 曖昧な構文解析を防ぐため、 :class:`str` 、 ``None`` 、 :data:`typing.Optional` 、そして :class:`~ext.commands.Greedy` を :class:`~ext.commands.Greedy` コンバーターのパラメーターにするのは禁止されています。

en: The :class:`discord.Attachment` converter is a special converter that retrieves an attachment from the uploaded attachments on a message. This converter *does not* look at the message content at all and just the uploaded attachments.
ja_JP: :class:`discord.Attachment` コンバータはメッセージにアップロードされた添付ファイルから添付ファイルを一個取得する特別なコンバータです。このコンバータは、メッセージ内容は *確認せず* アップロードされた添付ファイルのみ確認します。

en: When this command is invoked, the user must directly upload a file for the command body to be executed. When combined with the :data:`typing.Optional` converter, the user does not have to provide an attachment.
ja_JP: コマンドの呼び出し時に、ユーザーはコマンドを実行するときにはファイルを直接アップロードしないといけません。これを :data:`typing.Optional` コンバータと組み合わせた場合、添付ファイルを提供する必要はありません。

en: This also works with multiple attachments:
ja_JP: これは複数の添付ファイルでも動作します：

en: In this example the user must provide at least one file but the second one is optional.
ja_JP: この例では、ユーザーは少なくとも1つのファイルを提供する必要がありますが、2つ目のファイルはオプションです。

en: As a special case, using :class:`~ext.commands.Greedy` will return the remaining attachments in the message, if any.
ja_JP: 特別なケースとして、 :class:`~ext.commands.Greedy` を使用すると、存在する場合はメッセージ内の残りの添付ファイルが返されます。

en: Note that using a :class:`discord.Attachment` converter after a :class:`~ext.commands.Greedy` of :class:`discord.Attachment` will always fail since the greedy had already consumed the remaining attachments.
ja_JP: なお、 :class:`discord.Attachment` の :class:`~ext.commands.Greedy` の後に :class:`discord.Attachment` コンバータを使用するのは、Greedyが残りの添付ファイルをすでに使用しているため、常に失敗します。

en: If an attachment is expected but not given, then :exc:`~ext.commands.MissingRequiredAttachment` is raised to the error handlers.
ja_JP: 添付ファイルが期待されているのに与えられていない場合、 :exc:`~ext.commands.MissingRequiredAttachment` がエラーハンドラに送出されます。

en: A :class:`~ext.commands.FlagConverter` allows the user to specify user-friendly "flags" using :pep:`526` type annotations or a syntax more reminiscent of the :mod:`py:dataclasses` module.
ja_JP: :class:`~ext.commands.FlagConverter` を使用すると、型アノテーション :pep:`526` を使用してユーザーフレンドリーな「フラグ」を指定したり、 :mod:`py:dataclasses` モジュールを彷彿とさせる構文を使用できます。

en: For example, the following code:
ja_JP: 例えば、以下のコードです。

en: Allows the user to invoke the command using a simple flag-like syntax:
ja_JP: フラグに似たシンプルな構文を使用してコマンドを呼び出すことができます：

en: Flags use a syntax that allows the user to not require quotes when passing in values to the flag. The goal of the flag syntax is to be as user-friendly as possible. This makes flags a good choice for complicated commands that can have multiple knobs to turn or simulating keyword-only parameters in your external command interface. **It is recommended to use keyword-only parameters with the flag converter**. This ensures proper parsing and behaviour with quoting.
ja_JP: フラグは、フラグに値を渡す際に引用符を必要としない構文を使用しています。フラグ構文の目標は、できるだけユーザーフレンドリーにすることです。このため、複数のノブを使用する複雑なコマンドや、外部コマンド・インターフェースでキーワードのみのパラメータをシミュレートする場合、フラグを使用するのが適しています。 **フラグ・コンバータでは、キーワード専用パラメータを使用することをお勧めします。** これにより、適切な解析と引用符での動作が保証されます。

en: Internally, the :class:`~ext.commands.FlagConverter` class examines the class to find flags. A flag can either be a class variable with a type annotation or a class variable that's been assigned the result of the :func:`~ext.commands.flag` function. These flags are then used to define the interface that your users will use. The annotations correspond to the converters that the flag arguments must adhere to.
ja_JP: 内部的には、:class:`~ext.commands.FlagConverter` クラスがクラスを調べてフラグを見つけます。フラグには、型アノテーションが付いたクラス変数と、 :func:`~ext.commands.flag` 関数の結果が代入されたクラス変数があります。これらのフラグは、ユーザーが使用するインターフェースを定義するために使用されます。アノテーションは、フラグの引数が準拠しなければならないコンバーターに対応しています。

en: For most use cases, no extra work is required to define flags. However, if customisation is needed to control the flag name or the default value then the :func:`~ext.commands.flag` function can come in handy:
ja_JP: ほとんどの場合、フラグを定義するために余分な作業は必要ありません。 しかし、フラグ名やデフォルト値を制御するためにカスタマイズが必要な場合は、 :func:`~ext.commands.flag` 関数が便利です：

en: This tells the parser that the ``members`` attribute is mapped to a flag named ``member`` and that the default value is an empty list. For greater customisability, the default can either be a value or a callable that takes the :class:`~ext.commands.Context` as a sole parameter. This callable can either be a function or a coroutine.
ja_JP: これは ``members`` 属性が ``member`` というフラグにマップされ、デフォルト値が空のリストであることをパーサーに伝えます。 カスタマイズ性を向上させるために、デフォルトは値か呼び出し可能な値で、 :class:`~ext.commands.Context` を唯一のパラメータとして取ります。この呼び出し可能な値は関数またはコルーチンのいずれかを使用できます。

en: In order to customise the flag syntax we also have a few options that can be passed to the class parameter list:
ja_JP: フラグ構文をカスタマイズするために、クラスのパラメーターリストに渡せるオプションもいくつか用意されています。

en: Despite the similarities in these examples to command like arguments, the syntax and parser is not a command line parser. The syntax is mainly inspired by Discord's search bar input and as a result all flags need a corresponding value.
ja_JP: これらの例では引数のようにコマンドを実行するのと似ていますが、この構文と解析機はコマンドライン解析機ではありません。 この構文は主にDiscordの検索バー入力に触発されており、その結果、すべてのフラグに対応する値が必要になります。

en: Flag converters will only raise :exc:`~ext.commands.FlagError` derived exceptions. If an error is raised while converting a flag, :exc:`~ext.commands.BadFlagArgument` is raised instead and the original exception can be accessed with the :attr:`~ext.commands.BadFlagArgument.original` attribute.
ja_JP: フラグコンバータは :exc:`~ext.commands.FlagError` 派生の例外のみ送出します。フラグ変換中にエラーが発生した場合、 :exc:`~ext.commands.BadFlagArgument` が代わりに送出され、元の例外は :attr:`~ext.commands.BadFlagArgument.original` 属性でアクセスできます。

en: The flag converter is similar to regular commands and allows you to use most types of converters (with the exception of :class:`~ext.commands.Greedy`) as the type annotation. Some extra support is added for specific annotations as described below.
ja_JP: フラグコンバーターは通常のコマンドと似ており、ほとんどのタイプのコンバータを型アノテーションとして使用できます(例外は :class:`~ext.commands.Greedy`) 。以下で説明するように、特定のアノテーションに対する追加のサポートが追加されます。

en: If a list is given as a flag annotation it tells the parser that the argument can be passed multiple times.
ja_JP: リストがフラグアノテーションとして与えられた場合、引数が何回も渡せることをパーサーに知らせます。

en: For example, augmenting the example above:
ja_JP: 例えば、上記の例を拡張すると：

en: This is called by repeatedly specifying the flag:
ja_JP: これはフラグを繰り返し指定することで呼び出されます：

en: Since the above syntax can be a bit repetitive when specifying a flag many times, the :class:`py:tuple` type annotation allows for "greedy-like" semantics using a variadic tuple:
ja_JP: フラグを何度も指定する場合、上記の構文は少し繰り返しになるので、 :class:`py:tuple` 型アノテーションを使用すると、可変タプルを使用した「欲張りな」セマンティクスを実現することができます。

en: This allows the previous ``ban`` command to be called like this:
ja_JP: これにより、以前の ``ban`` コマンドを以下のように呼び出すことができます。

en: The :class:`py:tuple` annotation also allows for parsing of pairs. For example, given the following code:
ja_JP: :class:`py:tuple` アノテーションはペアの解析を可能にします。例えば、以下のコードがあります。

en: Due to potential parsing ambiguities, the parser expects tuple arguments to be quoted if they require spaces. So if one of the inner types is :class:`str` and the argument requires spaces then quotes should be used to disambiguate it from the other element of the tuple.
ja_JP: 解析が曖昧になってしまうため、パーサーはタプル引数がスペースを必要とする場合、引用符で囲むことを期待します。そのため、もし内部型のひとつが :class:`str` で、その引数がスペースを必要とする場合には、タプルの他の要素と区別するために引用符が使用されなければなりません。

en: A :class:`dict` annotation is functionally equivalent to ``List[Tuple[K, V]]`` except with the return type given as a :class:`dict` rather than a :class:`list`.
ja_JP: :class:`dict` アノテーションは、:class:`list` ではなく、:class:`dict` として与えられた戻り値の値を除いて、``List[Tuple[K, V]]`` と同等です

en: Hybrid Command Interaction
ja_JP: ハイブリッドコマンドでの動作

en: When used as a hybrid command, the parameters are flattened into different parameters for the application command. For example, the following converter:
ja_JP: ハイブリッドコマンドとして使用された場合、パラメータはアプリケーションコマンドでは別々のものになります。例えば、次のコンバータは：

en: Would be equivalent to an application command defined as this:
ja_JP: 以下のように定義されたアプリケーションコマンドと同等です：

en: This means that decorators that refer to a parameter by name will use the flag name instead:
ja_JP: これは、パラメータを名前で参照するデコレータはフラグ名を代わりに使用するということです。

en: For ease of use, the :func:`~ext.commands.flag` function accepts a ``description`` keyword argument to allow you to pass descriptions inline:
ja_JP: 使いやすいように、 :func:`~ext.commands.flag` 関数は ``description`` キーワード引数を受け取るので、説明をインラインで渡すことができます。

en: Likewise, use of the ``name`` keyword argument allows you to pass renames for the parameter, similar to the :func:`~discord.app_commands.rename` decorator.
ja_JP: 同様に、 ``name`` キーワード引数を使用すると、 :func:`~discord.app_commands.rename` デコレータと同様に、パラメータの改名ができます。

en: Note that in hybrid command form, a few annotations are unsupported due to Discord limitations:
ja_JP: ハイブリッドコマンド形式では、Discordの制限によりいくつかのアノテーションがサポートされていないことに注意してください。

en: Only one flag converter is supported per hybrid command. Due to the flag converter's way of working, it is unlikely for a user to have two of them in one signature.
ja_JP: ハイブリッドコマンド1個ごとにフラグコンバータ1個までサポートされています。 フラグコンバーターの動作の仕組みのため、あるシグネチャに2個フラグコンバータが存在するのはまれです。

en: Parameter Metadata
ja_JP: パラメータのメタデータ

en: :func:`~ext.commands.parameter` assigns custom metadata to a :class:`~ext.commands.Command`'s parameter.
ja_JP: :func:`~ext.commands.parameter` はカスタムメタデータを :class:`~ext.commands.Command` のパラメータに割り当てます。

en: This is useful for:
ja_JP: これは以下の場合に便利です:

en: Custom converters as annotating a parameter with a custom converter works at runtime, type checkers don't like it because they can't understand what's going on.
ja_JP: パラメータのアノテーションにカスタムコンバーターを付するカスタムコンバーターはランタイムで動作するため、型チェッカが理解できず、問題が発生します。

en: However, fear not we can use :func:`~ext.commands.parameter` to tell type checkers what's going on.
ja_JP: しかし、 :func:`~ext.commands.parameter` を使用すれば、型チェッカが何が起こっているかを理解できるようになります。

en: Late binding behaviour
ja_JP: 既定値の動的評価

en: Because this is such a common use-case, the library provides :obj:`~.ext.commands.Author`, :obj:`~.ext.commands.CurrentChannel` and :obj:`~.ext.commands.CurrentGuild`, armed with this we can simplify ``wave`` to:
ja_JP: これが非常に一般的な使用法であることから、ライブラリは :obj:`~.ext.commands.Author` 、 :obj:`~.ext.commands.CurrentChannel` 、 :obj:`~.ext.commands.CurrentGuild` を提供します。これらを使用すると ``wave`` は以下のように簡素化できます：

en: :obj:`~.ext.commands.Author` and co also have other benefits like having the displayed default being filled.
ja_JP: :obj:`~.ext.commands.Author` などは、表示される既定値が事前に指定されているなど、他の利点もあります。

en: Error Handling
ja_JP: エラーハンドリング

en: When our commands fail to parse we will, by default, receive a noisy error in ``stderr`` of our console that tells us that an error has happened and has been silently ignored.
ja_JP: コマンドの解析に失敗すると、デフォルトではエラーの発生とそれが握り潰されたことを知らせるノイズのようなエラーがコンソールの ``stderr`` に出力されます。

en: In order to handle our errors, we must use something called an error handler. There is a global error handler, called :func:`.on_command_error` which works like any other event in the :ref:`discord-api-events`. This global error handler is called for every error reached.
ja_JP: エラーを処理するには、エラーハンドラと呼ばれるものを利用する必要があります。
    :func:`.on_command_error` グローバルエラーハンドラが存在し、これは :ref:`discord-api-events` のイベントのように動作します。
    このハンドラはエラーが発生するたびに呼び出されます。

en: Most of the time however, we want to handle an error local to the command itself. Luckily, commands come with local error handlers that allow us to do just that. First we decorate an error handler function with :meth:`~discord.ext.commands.Command.error`:
ja_JP: しかし、ほとんどの場合においては、コマンド自体に対応するローカルなエラー処理を行いたいと考えるでしょう。幸いなことに、コマンドにはローカルエラーハンドラが存在するため、これを利用して実現することができます。まず、エラーハンドラとして利用する関数を :meth:`~discord.ext.commands.Command.error` でデコレートします。

en: The first parameter of the error handler is the :class:`.Context` while the second one is an exception that is derived from :exc:`~ext.commands.CommandError`. A list of errors is found in the :ref:`ext_commands_api_errors` page of the documentation.
ja_JP: ハンドラの最初の引数には :class:`.Context` が渡され、２番目の引数には :exc:`~ext.commands.CommandError` が渡されます。 エラー一覧は :ref:`ext_commands_api_errors` から見ることができます。

en: Checks
ja_JP: チェック

en: There are cases when we don't want a user to use our commands. They don't have permissions to do so or maybe we blocked them from using our bot earlier. The commands extension comes with full support for these things in a concept called a :ref:`ext_commands_api_checks`.
ja_JP: コマンドをユーザーに使ってほしくない場合などがあります。例えば、使用者が権限を持っていない場合や、ボットによりブロックされている場合などです。コマンド拡張機能ではこのような機能を :ref:`ext_commands_api_checks` と呼び、完全にサポートしています。

en: A check is a basic predicate that can take in a :class:`.Context` as its sole parameter. Within it, you have the following options:
ja_JP: チェックは :class:`.Context` を引数とする関数です。関数はこれらの選択ができます：

en: Return ``True`` to signal that the person can run the command.
ja_JP: ``True`` を返し、その人がコマンドを実行できることを示します。

en: Return ``False`` to signal that the person cannot run the command.
ja_JP: ``False`` を返し、その人がコマンドを実行できないことを示します。

en: Raise a :exc:`~ext.commands.CommandError` derived exception to signal the person cannot run the command.
ja_JP: :exc:`~ext.commands.CommandError` を継承する例外を発生させ、コマンドを実行できないことを示します。

en: This allows you to have custom error messages for you to handle in the :ref:`error handlers <ext_commands_error_handler>`.
ja_JP: :ref:`エラーハンドラ <ext_commands_error_handler>` のように独自のエラーメッセージを使うことができます。

en: To register a check for a command, we would have two ways of doing so. The first is using the :meth:`~ext.commands.check` decorator. For example:
ja_JP: チェックを登録するには２つの方法があります：１つ目は :meth:`~ext.commands.check` を使う方法です。

en: This would only evaluate the command if the function ``is_owner`` returns ``True``. Sometimes we re-use a check often and want to split it into its own decorator. To do that we can just add another level of depth:
ja_JP: 例えば、この場合は ``is_owner`` が ``True`` だったときのみコマンドを実行します。しかし、チェックを使い回すために独自のデコレーターにしたくなることもあるでしょう。そうしたい場合は、

en: Since an owner check is so common, the library provides it for you (:func:`~ext.commands.is_owner`):
ja_JP: このようにすると独自のデコレーターになります。
    このチェックはとてもよく使われるため、ライブラリに標準で実装されています（ :func:`~ext.commands.is_owner` ）。

en: When multiple checks are specified, **all** of them must be ``True``:
ja_JP: 複数のチェックが渡されたときには、 **すべて** のチェックが ``True`` になる必要があります。

en: If any of those checks fail in the example above, then the command will not be run.
ja_JP: もしチェックのうちどれかが失敗した場合、コマンドは実行されません。

en: When an error happens, the error is propagated to the :ref:`error handlers <ext_commands_error_handler>`. If you do not raise a custom :exc:`~ext.commands.CommandError` derived exception, then it will get wrapped up into a :exc:`~ext.commands.CheckFailure` exception as so:
ja_JP: もし例外が発生した場合、 :ref:`エラーハンドラ<ext_commands_error_handler>` によって例外が処理されます。もし :exc:`~ext.commands.CommandError` を継承しないエラーを発生させた場合、 :exc:`~ext.commands.CheckFailure` が発生します。

en: If you want a more robust error system, you can derive from the exception and raise it instead of returning ``False``:
ja_JP: もし強化されたエラーシステムが必要な場合は、例外を継承し、``False`` を返す代わりに例外を発生させることができます。

en: Since having a ``guild_only`` decorator is pretty common, it comes built-in via :func:`~ext.commands.guild_only`.
ja_JP: ``guild_only`` デコレータはよく使われるため、標準で実装されています（ :func:`~ext.commands.guild_only` ）。

en: Global Checks
ja_JP: グローバルチェック

en: Sometimes we want to apply a check to **every** command, not just certain commands. The library supports this as well using the global check concept.
ja_JP: **すべての** コマンドにチェックをかけたいこともあるでしょう。そうしたい場合は、ライブラリのグローバルチェックを使うことができます。

en: Global checks work similarly to regular checks except they are registered with the :meth:`.Bot.check` decorator.
ja_JP: グローバルチェックは、 :meth:`.Bot.check` デコレータで登録されることを除き、通常のチェックと同様に動作します。

en: For example, to block all DMs we could do the following:
ja_JP: 例えば、全DMをブロックするには、次の操作を行います。

en: Be careful on how you write your global checks, as it could also lock you out of your own bot.
ja_JP: グローバルチェックを追加するときには注意して下さい。ボットを操作できなくなる可能性があります。

en: Hybrid Commands
ja_JP: ハイブリッドコマンド

en: :class:`.commands.HybridCommand` is a command that can be invoked as both a text and a slash command. This allows you to define a command as both slash and text command without writing separate code for both counterparts.
ja_JP: :class:`.commands.HybridCommand` は、テキストコマンドとしても、スラッシュコマンドとしても呼び出せるコマンドです。これを使用すれば、別々のコードを書かずにコマンドをスラッシュコマンドとテキストコマンドの両方として定義できます。

en: In order to define a hybrid command, The command callback should be decorated with :meth:`.Bot.hybrid_command` decorator.
ja_JP: ハイブリッドコマンドを定義するには、コマンドコールバックを :meth:`.Bot.hybrid_command` デコレータで装飾しないといけません。

en: The above command can be invoked as both text and slash command. Note that you have to manually sync your :class:`~app_commands.CommandTree` by calling :class:`~app_commands.CommandTree.sync` in order for slash commands to appear.
ja_JP: 上のコマンドはテキストコマンドとスラッシュコマンドの両方として実行できます。なお、スラッシュコマンドを表示するには、 :class:`~app_commands.CommandTree.sync` を呼び出して :class:`~app_commands.CommandTree` を手動で同期しないといけません。

en: You can create hybrid command groups and sub-commands using the :meth:`.Bot.hybrid_group` decorator.
ja_JP: :meth:`.Bot.hybrid_group` デコレータを使用して、ハイブリッドコマンドグループとサブコマンドを作成できます。

en: Due to a Discord limitation, slash command groups cannot be invoked directly so the ``fallback`` parameter allows you to create a sub-command that will be bound to callback of parent group.
ja_JP: Discordの制限により、 スラッシュコマンドグループは直接呼び出すことができないため、 ``fallback`` パラメータを使用して、親グループのコールバックを呼び出すサブコマンドを作成できます。

en: Due to certain limitations on slash commands, some features of text commands are not supported on hybrid commands. You can define a hybrid command as long as it meets the same subset that is supported for slash commands.
ja_JP: スラッシュコマンドには制限があるため、ハイブリッドコマンドではテキストコマンドの一部の機能がサポートされていません。スラッシュコマンドでサポートされている機能のみ使用している場合にハイブリッドコマンドを定義できます。

en: Following are currently **not supported** by hybrid commands:
ja_JP: 以下は現時点でハイブリッドコマンドではサポート **されていません**:

en: Variable number of arguments. e.g. ``*arg: int``
ja_JP: 可変長引数。例: ``*arg: int``

en: Group commands with a depth greater than 1.
ja_JP: 深さが1より大きいグループコマンド。

en: Most :class:`typing.Union` types.
ja_JP: ほとんどの :class:`typing.Union` 型。

en: Unions of channel types are allowed
ja_JP: チャンネルの型のユニオン型は使用できます

en: Unions of user types are allowed
ja_JP: ユーザーの型のユニオン型は使用できます

en: Unions of user types with roles are allowed
ja_JP: チャンネルの型とロールの型のユニオン型は使用できます

en: Apart from that, all other features such as converters, checks, autocomplete, flags etc. are supported on hybrid commands. Note that due to a design constraint, decorators related to application commands such as :func:`discord.app_commands.autocomplete` should be placed below the :func:`~ext.commands.hybrid_command` decorator.
ja_JP: それ以外の、コンバーター、チェック、オートコンプリート、フラグ、その他はすべてハイブリッドコマンドで利用できます。なお、設計上の制限により、 :func:`discord.app_commands.autocomplete` といったアプリケーションコマンド関連のデコレータは :func:`~ext.commands.hybrid_command` デコレータの下に配置しないといけません。

en: For convenience and ease in writing code, The :class:`~ext.commands.Context` class implements some behavioural changes for various methods and attributes:
ja_JP: コードを簡単に書くために、 :class:`~ext.commands.Context` クラスのメソッドや属性の動作が変化します:

en: :attr:`.Context.interaction` can be used to retrieve the slash command interaction.
ja_JP: :attr:`.Context.interaction` を用いてスラッシュコマンドのインタラクションを取得できます。

en: Since interaction can only be responded to once, The :meth:`.Context.send` automatically determines whether to send an interaction response or a followup response.
ja_JP: インタラクションは一度しか応答できないため、 :meth:`.Context.send` は、インタラクション応答とフォローアップ応答のどちらを送信するかを自動的に決定します。

en: :meth:`.Context.defer` defers the interaction response for slash commands but shows typing indicator for text commands.
ja_JP: :meth:`.Context.defer` はスラッシュコマンドではインタラクション応答を遅らせ、テキストコマンドでは入力インジケーターを表示します。
