{- ORMOLU_DISABLE -}
{- HLINT ignore -}
-- THIS IS A GENERATED FILE, DO NOT EDIT

{-# OPTIONS_GHC -Wno-unused-imports #-}
{-# OPTIONS_GHC -Wno-unused-matches #-}
{-# OPTIONS_GHC -Wno-deprecations #-}
module Language.LSP.Protocol.Internal.Types.CompletionItem where

import Control.DeepSeq
import Data.Hashable
import GHC.Generics
import Language.LSP.Protocol.Utils.Misc
import Prettyprinter
import qualified Data.Aeson
import qualified Data.Aeson as Aeson
import qualified Data.Row.Aeson as Aeson
import qualified Data.Row.Hashable as Hashable
import qualified Data.Text
import qualified Language.LSP.Protocol.Internal.Types.Command
import qualified Language.LSP.Protocol.Internal.Types.CompletionItemKind
import qualified Language.LSP.Protocol.Internal.Types.CompletionItemLabelDetails
import qualified Language.LSP.Protocol.Internal.Types.CompletionItemTag
import qualified Language.LSP.Protocol.Internal.Types.InsertReplaceEdit
import qualified Language.LSP.Protocol.Internal.Types.InsertTextFormat
import qualified Language.LSP.Protocol.Internal.Types.InsertTextMode
import qualified Language.LSP.Protocol.Internal.Types.MarkupContent
import qualified Language.LSP.Protocol.Internal.Types.TextEdit
import qualified Language.LSP.Protocol.Types.Common

{-|
A completion item represents a text snippet that is
proposed to complete text that is being typed.
-}
data CompletionItem = CompletionItem 
  { {-|
  The label of this completion item.

  The label property is also by default the text that
  is inserted when selecting this completion.

  If label details are provided the label itself should
  be an unqualified name of the completion item.
  -}
  CompletionItem -> Text
_label :: Data.Text.Text
  , {-|
  Additional details for the label

  @since 3.17.0
  -}
  CompletionItem -> Maybe CompletionItemLabelDetails
_labelDetails :: (Maybe Language.LSP.Protocol.Internal.Types.CompletionItemLabelDetails.CompletionItemLabelDetails)
  , {-|
  The kind of this completion item. Based of the kind
  an icon is chosen by the editor.
  -}
  CompletionItem -> Maybe CompletionItemKind
_kind :: (Maybe Language.LSP.Protocol.Internal.Types.CompletionItemKind.CompletionItemKind)
  , {-|
  Tags for this completion item.

  @since 3.15.0
  -}
  CompletionItem -> Maybe [CompletionItemTag]
_tags :: (Maybe [Language.LSP.Protocol.Internal.Types.CompletionItemTag.CompletionItemTag])
  , {-|
  A human-readable string with additional information
  about this item, like type or symbol information.
  -}
  CompletionItem -> Maybe Text
_detail :: (Maybe Data.Text.Text)
  , {-|
  A human-readable string that represents a doc-comment.
  -}
  CompletionItem -> Maybe (Text |? MarkupContent)
_documentation :: (Maybe (Data.Text.Text Language.LSP.Protocol.Types.Common.|? Language.LSP.Protocol.Internal.Types.MarkupContent.MarkupContent))
  , {-|
  Indicates if this item is deprecated.
  @deprecated Use `tags` instead.
  -}
  CompletionItem -> Maybe Bool
_deprecated :: (Maybe Bool)
  , {-|
  Select this item when showing.

  *Note* that only one completion item can be selected and that the
  tool / client decides which item that is. The rule is that the *first*
  item of those that match best is selected.
  -}
  CompletionItem -> Maybe Bool
_preselect :: (Maybe Bool)
  , {-|
  A string that should be used when comparing this item
  with other items. When `falsy` the `CompletionItem.label`
  is used.
  -}
  CompletionItem -> Maybe Text
_sortText :: (Maybe Data.Text.Text)
  , {-|
  A string that should be used when filtering a set of
  completion items. When `falsy` the `CompletionItem.label`
  is used.
  -}
  CompletionItem -> Maybe Text
_filterText :: (Maybe Data.Text.Text)
  , {-|
  A string that should be inserted into a document when selecting
  this completion. When `falsy` the `CompletionItem.label`
  is used.

  The `insertText` is subject to interpretation by the client side.
  Some tools might not take the string literally. For example
  VS Code when code complete is requested in this example
  `con<cursor position>` and a completion item with an `insertText` of
  `console` is provided it will only insert `sole`. Therefore it is
  recommended to use `textEdit` instead since it avoids additional client
  side interpretation.
  -}
  CompletionItem -> Maybe Text
_insertText :: (Maybe Data.Text.Text)
  , {-|
  The format of the insert text. The format applies to both the
  `insertText` property and the `newText` property of a provided
  `textEdit`. If omitted defaults to `InsertTextFormat.PlainText`.

  Please note that the insertTextFormat doesn't apply to
  `additionalTextEdits`.
  -}
  CompletionItem -> Maybe InsertTextFormat
_insertTextFormat :: (Maybe Language.LSP.Protocol.Internal.Types.InsertTextFormat.InsertTextFormat)
  , {-|
  How whitespace and indentation is handled during completion
  item insertion. If not provided the clients default value depends on
  the `textDocument.completion.insertTextMode` client capability.

  @since 3.16.0
  -}
  CompletionItem -> Maybe InsertTextMode
_insertTextMode :: (Maybe Language.LSP.Protocol.Internal.Types.InsertTextMode.InsertTextMode)
  , {-|
  An `TextEdit` which is applied to a document when selecting
  this completion. When an edit is provided the value of
  `CompletionItem.insertText` is ignored.

  Most editors support two different operations when accepting a completion
  item. One is to insert a completion text and the other is to replace an
  existing text with a completion text. Since this can usually not be
  predetermined by a server it can report both ranges. Clients need to
  signal support for `InsertReplaceEdits` via the
  `textDocument.completion.insertReplaceSupport` client capability
  property.

  *Note 1:* The text edit's range as well as both ranges from an insert
  replace edit must be a [single line] and they must contain the position
  at which completion has been requested.
  *Note 2:* If an `InsertReplaceEdit` is returned the edit's insert range
  must be a prefix of the edit's replace range, that means it must be
  contained and starting at the same position.

  @since 3.16.0 additional type `InsertReplaceEdit`
  -}
  CompletionItem -> Maybe (TextEdit |? InsertReplaceEdit)
_textEdit :: (Maybe (Language.LSP.Protocol.Internal.Types.TextEdit.TextEdit Language.LSP.Protocol.Types.Common.|? Language.LSP.Protocol.Internal.Types.InsertReplaceEdit.InsertReplaceEdit))
  , {-|
  The edit text used if the completion item is part of a CompletionList and
  CompletionList defines an item default for the text edit range.

  Clients will only honor this property if they opt into completion list
  item defaults using the capability `completionList.itemDefaults`.

  If not provided and a list's default range is provided the label
  property is used as a text.

  @since 3.17.0
  -}
  CompletionItem -> Maybe Text
_textEditText :: (Maybe Data.Text.Text)
  , {-|
  An optional array of additional `TextEdit` that are applied when
  selecting this completion. Edits must not overlap (including the same insert position)
  with the main `CompletionItem.textEdit` nor with themselves.

  Additional text edits should be used to change text unrelated to the current cursor position
  (for example adding an import statement at the top of the file if the completion item will
  insert an unqualified type).
  -}
  CompletionItem -> Maybe [TextEdit]
_additionalTextEdits :: (Maybe [Language.LSP.Protocol.Internal.Types.TextEdit.TextEdit])
  , {-|
  An optional set of characters that when pressed while this completion is active will accept it first and
  then type that character. *Note* that all commit characters should have `length=1` and that superfluous
  characters will be ignored.
  -}
  CompletionItem -> Maybe [Text]
_commitCharacters :: (Maybe [Data.Text.Text])
  , {-|
  An optional `Command` that is executed *after* inserting this completion. *Note* that
  additional modifications to the current document should be described with the
  `CompletionItem.additionalTextEdits`-property.
  -}
  CompletionItem -> Maybe Command
_command :: (Maybe Language.LSP.Protocol.Internal.Types.Command.Command)
  , {-|
  A data entry field that is preserved on a completion item between a
  `CompletionRequest`.
  -}
  CompletionItem -> Maybe Value
_data_ :: (Maybe Data.Aeson.Value)
  }
  deriving stock (Int -> CompletionItem -> ShowS
[CompletionItem] -> ShowS
CompletionItem -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompletionItem] -> ShowS
$cshowList :: [CompletionItem] -> ShowS
show :: CompletionItem -> String
$cshow :: CompletionItem -> String
showsPrec :: Int -> CompletionItem -> ShowS
$cshowsPrec :: Int -> CompletionItem -> ShowS
Show, CompletionItem -> CompletionItem -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompletionItem -> CompletionItem -> Bool
$c/= :: CompletionItem -> CompletionItem -> Bool
== :: CompletionItem -> CompletionItem -> Bool
$c== :: CompletionItem -> CompletionItem -> Bool
Eq, Eq CompletionItem
CompletionItem -> CompletionItem -> Bool
CompletionItem -> CompletionItem -> Ordering
CompletionItem -> CompletionItem -> CompletionItem
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CompletionItem -> CompletionItem -> CompletionItem
$cmin :: CompletionItem -> CompletionItem -> CompletionItem
max :: CompletionItem -> CompletionItem -> CompletionItem
$cmax :: CompletionItem -> CompletionItem -> CompletionItem
>= :: CompletionItem -> CompletionItem -> Bool
$c>= :: CompletionItem -> CompletionItem -> Bool
> :: CompletionItem -> CompletionItem -> Bool
$c> :: CompletionItem -> CompletionItem -> Bool
<= :: CompletionItem -> CompletionItem -> Bool
$c<= :: CompletionItem -> CompletionItem -> Bool
< :: CompletionItem -> CompletionItem -> Bool
$c< :: CompletionItem -> CompletionItem -> Bool
compare :: CompletionItem -> CompletionItem -> Ordering
$ccompare :: CompletionItem -> CompletionItem -> Ordering
Ord, forall x. Rep CompletionItem x -> CompletionItem
forall x. CompletionItem -> Rep CompletionItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CompletionItem x -> CompletionItem
$cfrom :: forall x. CompletionItem -> Rep CompletionItem x
Generic)
  deriving anyclass (CompletionItem -> ()
forall a. (a -> ()) -> NFData a
rnf :: CompletionItem -> ()
$crnf :: CompletionItem -> ()
NFData, Eq CompletionItem
Int -> CompletionItem -> Int
CompletionItem -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: CompletionItem -> Int
$chash :: CompletionItem -> Int
hashWithSalt :: Int -> CompletionItem -> Int
$chashWithSalt :: Int -> CompletionItem -> Int
Hashable)
  deriving forall ann. [CompletionItem] -> Doc ann
forall ann. CompletionItem -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
prettyList :: forall ann. [CompletionItem] -> Doc ann
$cprettyList :: forall ann. [CompletionItem] -> Doc ann
pretty :: forall ann. CompletionItem -> Doc ann
$cpretty :: forall ann. CompletionItem -> Doc ann
Pretty via (ViaJSON CompletionItem)

instance Aeson.ToJSON CompletionItem where
  toJSON :: CompletionItem -> Value
toJSON (CompletionItem Text
arg0 Maybe CompletionItemLabelDetails
arg1 Maybe CompletionItemKind
arg2 Maybe [CompletionItemTag]
arg3 Maybe Text
arg4 Maybe (Text |? MarkupContent)
arg5 Maybe Bool
arg6 Maybe Bool
arg7 Maybe Text
arg8 Maybe Text
arg9 Maybe Text
arg10 Maybe InsertTextFormat
arg11 Maybe InsertTextMode
arg12 Maybe (TextEdit |? InsertReplaceEdit)
arg13 Maybe Text
arg14 Maybe [TextEdit]
arg15 Maybe [Text]
arg16 Maybe Command
arg17 Maybe Value
arg18) = [Pair] -> Value
Aeson.object forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall a b. (a -> b) -> a -> b
$  [[Key
"label" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Aeson..= Text
arg0]
    ,String
"labelDetails" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe CompletionItemLabelDetails
arg1
    ,String
"kind" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe CompletionItemKind
arg2
    ,String
"tags" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe [CompletionItemTag]
arg3
    ,String
"detail" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe Text
arg4
    ,String
"documentation" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe (Text |? MarkupContent)
arg5
    ,String
"deprecated" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe Bool
arg6
    ,String
"preselect" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe Bool
arg7
    ,String
"sortText" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe Text
arg8
    ,String
"filterText" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe Text
arg9
    ,String
"insertText" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe Text
arg10
    ,String
"insertTextFormat" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe InsertTextFormat
arg11
    ,String
"insertTextMode" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe InsertTextMode
arg12
    ,String
"textEdit" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe (TextEdit |? InsertReplaceEdit)
arg13
    ,String
"textEditText" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe Text
arg14
    ,String
"additionalTextEdits" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe [TextEdit]
arg15
    ,String
"commitCharacters" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe [Text]
arg16
    ,String
"command" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe Command
arg17
    ,String
"data" forall kv v. (KeyValue kv, ToJSON v) => String -> Maybe v -> [kv]
Language.LSP.Protocol.Types.Common..=? Maybe Value
arg18]

instance Aeson.FromJSON CompletionItem where
  parseJSON :: Value -> Parser CompletionItem
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
Aeson.withObject String
"CompletionItem" forall a b. (a -> b) -> a -> b
$ \Object
arg -> Text
-> Maybe CompletionItemLabelDetails
-> Maybe CompletionItemKind
-> Maybe [CompletionItemTag]
-> Maybe Text
-> Maybe (Text |? MarkupContent)
-> Maybe Bool
-> Maybe Bool
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe InsertTextFormat
-> Maybe InsertTextMode
-> Maybe (TextEdit |? InsertReplaceEdit)
-> Maybe Text
-> Maybe [TextEdit]
-> Maybe [Text]
-> Maybe Command
-> Maybe Value
-> CompletionItem
CompletionItem forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
arg forall a. FromJSON a => Object -> Key -> Parser a
Aeson..: Key
"label" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"labelDetails" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"kind" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"tags" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"detail" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"documentation" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"deprecated" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"preselect" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"sortText" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"filterText" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"insertText" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"insertTextFormat" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"insertTextMode" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"textEdit" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"textEditText" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"additionalTextEdits" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"commitCharacters" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"command" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
arg forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Aeson..:! Key
"data"