Copyright | (c) 2015-2016 Brendan Hay |
---|---|
License | Mozilla Public License, v. 2.0. |
Maintainer | Brendan Hay <brendan.g.hay@gmail.com> |
Stability | auto-generated |
Portability | non-portable (GHC extensions) |
Safe Haskell | None |
Language | Haskell2010 |
- Service Configuration
- OAuth Scopes
- API Declaration
- Resources
- Types
- AnalyzeSyntaxRequest
- DependencyEdge
- ClassifyTextRequest
- Status
- PartOfSpeechProper
- PartOfSpeechTag
- Sentiment
- DocumentType
- AnalyzeSyntaxRequestEncodingType
- AnalyzeEntitySentimentRequestEncodingType
- DependencyEdgeLabel
- PartOfSpeechVoice
- PartOfSpeechForm
- PartOfSpeechPerson
- Token
- EntityType
- StatusDetailsItem
- ClassificationCategory
- AnnotateTextRequest
- EntityMention
- TextSpan
- AnalyzeEntitySentimentRequest
- AnnotateTextResponse
- PartOfSpeechTense
- Features
- Document
- PartOfSpeechMood
- PartOfSpeechCase
- AnalyzeSentimentRequest
- Xgafv
- AnalyzeEntitiesResponse
- AnnotateTextRequestEncodingType
- PartOfSpeechNumber
- AnalyzeSentimentResponse
- AnalyzeEntitiesRequest
- AnalyzeEntitiesRequestEncodingType
- Entity
- AnalyzeEntitySentimentResponse
- AnalyzeSyntaxResponse
- EntityMetadata
- PartOfSpeechAspect
- ClassifyTextResponse
- PartOfSpeech
- PartOfSpeechReciprocity
- PartOfSpeechGender
- AnalyzeSentimentRequestEncodingType
- EntityMentionType
- Sentence
Provides natural language understanding technologies, such as sentiment analysis, entity recognition, entity sentiment analysis, and other text annotations, to developers.
Synopsis
- languageService :: ServiceConfig
- cloudLanguageScope :: Proxy '["https://www.googleapis.com/auth/cloud-language"]
- cloudPlatformScope :: Proxy '["https://www.googleapis.com/auth/cloud-platform"]
- type LanguageAPI = DocumentsAnalyzeSyntaxResource :<|> (DocumentsClassifyTextResource :<|> (DocumentsAnnotateTextResource :<|> (DocumentsAnalyzeEntitySentimentResource :<|> (DocumentsAnalyzeSentimentResource :<|> DocumentsAnalyzeEntitiesResource))))
- module Network.Google.Resource.Language.Documents.AnalyzeEntities
- module Network.Google.Resource.Language.Documents.AnalyzeEntitySentiment
- module Network.Google.Resource.Language.Documents.AnalyzeSentiment
- module Network.Google.Resource.Language.Documents.AnalyzeSyntax
- module Network.Google.Resource.Language.Documents.AnnotateText
- module Network.Google.Resource.Language.Documents.ClassifyText
- data AnalyzeSyntaxRequest
- analyzeSyntaxRequest :: AnalyzeSyntaxRequest
- asrEncodingType :: Lens' AnalyzeSyntaxRequest (Maybe AnalyzeSyntaxRequestEncodingType)
- asrDocument :: Lens' AnalyzeSyntaxRequest (Maybe Document)
- data DependencyEdge
- dependencyEdge :: DependencyEdge
- deHeadTokenIndex :: Lens' DependencyEdge (Maybe Int32)
- deLabel :: Lens' DependencyEdge (Maybe DependencyEdgeLabel)
- data ClassifyTextRequest
- classifyTextRequest :: ClassifyTextRequest
- ctrDocument :: Lens' ClassifyTextRequest (Maybe Document)
- data Status
- status :: Status
- sDetails :: Lens' Status [StatusDetailsItem]
- sCode :: Lens' Status (Maybe Int32)
- sMessage :: Lens' Status (Maybe Text)
- data PartOfSpeechProper
- data PartOfSpeechTag
- data Sentiment
- sentiment :: Sentiment
- sScore :: Lens' Sentiment (Maybe Double)
- sMagnitude :: Lens' Sentiment (Maybe Double)
- data DocumentType
- data AnalyzeSyntaxRequestEncodingType
- data AnalyzeEntitySentimentRequestEncodingType
- data DependencyEdgeLabel
- = DELUnknown
- | DELAbbrev
- | DELAcomp
- | DELAdvcl
- | DELAdvmod
- | DELAmod
- | DELAppos
- | DELAttr
- | DELAux
- | DELAuxpass
- | DELCC
- | DELCcomp
- | DELConj
- | DELCsubj
- | DELCsubjpass
- | DELDep
- | DELDet
- | DELDiscourse
- | DELDobj
- | DELExpl
- | DELGoeswith
- | DELIobj
- | DELMark
- | DELMwe
- | DELMwv
- | DELNeg
- | DELNN
- | DELNpadvmod
- | DELNsubj
- | DELNsubjpass
- | DELNum
- | DELNumber
- | DELP
- | DELParataxis
- | DELPartmod
- | DELPcomp
- | DELPobj
- | DELPoss
- | DELPostneg
- | DELPrecomp
- | DELPreconj
- | DELPredet
- | DELPref
- | DELPrep
- | DELPronl
- | DELPrt
- | DELPS
- | DELQuantmod
- | DELRcmod
- | DELRcmodrel
- | DELRdrop
- | DELRef
- | DELRemnant
- | DELReparandum
- | DELRoot
- | DELSnum
- | DELSuff
- | DELTmod
- | DELTopic
- | DELVMod
- | DELVocative
- | DELXcomp
- | DELSuffix
- | DELTitle
- | DELAdvphmod
- | DELAuxcaus
- | DELAuxvv
- | DELDtmod
- | DELForeign
- | DELKW
- | DELList
- | DELNomc
- | DELNomcsubj
- | DELNomcsubjpass
- | DELNumc
- | DELCop
- | DELDislocated
- | DELAsp
- | DELGmod
- | DELGobj
- | DELInfmod
- | DELMes
- | DELNcomp
- data PartOfSpeechVoice
- data PartOfSpeechForm
- = FormUnknown
- | Adnomial
- | Auxiliary
- | Complementizer
- | FinalEnding
- | Gerund
- | Realis
- | Irrealis
- | Short
- | Long
- | Order
- | Specific
- data PartOfSpeechPerson
- data Token
- token :: Token
- tDependencyEdge :: Lens' Token (Maybe DependencyEdge)
- tText :: Lens' Token (Maybe TextSpan)
- tLemma :: Lens' Token (Maybe Text)
- tPartOfSpeech :: Lens' Token (Maybe PartOfSpeech)
- data EntityType
- data StatusDetailsItem
- statusDetailsItem :: HashMap Text JSONValue -> StatusDetailsItem
- sdiAddtional :: Lens' StatusDetailsItem (HashMap Text JSONValue)
- data ClassificationCategory
- classificationCategory :: ClassificationCategory
- ccConfidence :: Lens' ClassificationCategory (Maybe Double)
- ccName :: Lens' ClassificationCategory (Maybe Text)
- data AnnotateTextRequest
- annotateTextRequest :: AnnotateTextRequest
- atrEncodingType :: Lens' AnnotateTextRequest (Maybe AnnotateTextRequestEncodingType)
- atrFeatures :: Lens' AnnotateTextRequest (Maybe Features)
- atrDocument :: Lens' AnnotateTextRequest (Maybe Document)
- data EntityMention
- entityMention :: EntityMention
- emSentiment :: Lens' EntityMention (Maybe Sentiment)
- emText :: Lens' EntityMention (Maybe TextSpan)
- emType :: Lens' EntityMention (Maybe EntityMentionType)
- data TextSpan
- textSpan :: TextSpan
- tsBeginOffSet :: Lens' TextSpan (Maybe Int32)
- tsContent :: Lens' TextSpan (Maybe Text)
- data AnalyzeEntitySentimentRequest
- analyzeEntitySentimentRequest :: AnalyzeEntitySentimentRequest
- aesrEncodingType :: Lens' AnalyzeEntitySentimentRequest (Maybe AnalyzeEntitySentimentRequestEncodingType)
- aesrDocument :: Lens' AnalyzeEntitySentimentRequest (Maybe Document)
- data AnnotateTextResponse
- annotateTextResponse :: AnnotateTextResponse
- atrEntities :: Lens' AnnotateTextResponse [Entity]
- atrTokens :: Lens' AnnotateTextResponse [Token]
- atrDocumentSentiment :: Lens' AnnotateTextResponse (Maybe Sentiment)
- atrCategories :: Lens' AnnotateTextResponse [ClassificationCategory]
- atrSentences :: Lens' AnnotateTextResponse [Sentence]
- atrLanguage :: Lens' AnnotateTextResponse (Maybe Text)
- data PartOfSpeechTense
- data Features
- features :: Features
- fExtractSyntax :: Lens' Features (Maybe Bool)
- fExtractDocumentSentiment :: Lens' Features (Maybe Bool)
- fClassifyText :: Lens' Features (Maybe Bool)
- fExtractEntitySentiment :: Lens' Features (Maybe Bool)
- fExtractEntities :: Lens' Features (Maybe Bool)
- data Document
- document :: Document
- dContent :: Lens' Document (Maybe Text)
- dLanguage :: Lens' Document (Maybe Text)
- dGcsContentURI :: Lens' Document (Maybe Text)
- dType :: Lens' Document (Maybe DocumentType)
- data PartOfSpeechMood
- data PartOfSpeechCase
- data AnalyzeSentimentRequest
- analyzeSentimentRequest :: AnalyzeSentimentRequest
- aEncodingType :: Lens' AnalyzeSentimentRequest (Maybe AnalyzeSentimentRequestEncodingType)
- aDocument :: Lens' AnalyzeSentimentRequest (Maybe Document)
- data Xgafv
- data AnalyzeEntitiesResponse
- analyzeEntitiesResponse :: AnalyzeEntitiesResponse
- aerEntities :: Lens' AnalyzeEntitiesResponse [Entity]
- aerLanguage :: Lens' AnalyzeEntitiesResponse (Maybe Text)
- data AnnotateTextRequestEncodingType
- data PartOfSpeechNumber
- = NumberUnknown
- | Singular
- | Plural
- | Dual
- data AnalyzeSentimentResponse
- analyzeSentimentResponse :: AnalyzeSentimentResponse
- asrDocumentSentiment :: Lens' AnalyzeSentimentResponse (Maybe Sentiment)
- asrSentences :: Lens' AnalyzeSentimentResponse [Sentence]
- asrLanguage :: Lens' AnalyzeSentimentResponse (Maybe Text)
- data AnalyzeEntitiesRequest
- analyzeEntitiesRequest :: AnalyzeEntitiesRequest
- aerEncodingType :: Lens' AnalyzeEntitiesRequest (Maybe AnalyzeEntitiesRequestEncodingType)
- aerDocument :: Lens' AnalyzeEntitiesRequest (Maybe Document)
- data AnalyzeEntitiesRequestEncodingType
- data Entity
- entity :: Entity
- eSentiment :: Lens' Entity (Maybe Sentiment)
- eName :: Lens' Entity (Maybe Text)
- eSalience :: Lens' Entity (Maybe Double)
- eMetadata :: Lens' Entity (Maybe EntityMetadata)
- eType :: Lens' Entity (Maybe EntityType)
- eMentions :: Lens' Entity [EntityMention]
- data AnalyzeEntitySentimentResponse
- analyzeEntitySentimentResponse :: AnalyzeEntitySentimentResponse
- aesrEntities :: Lens' AnalyzeEntitySentimentResponse [Entity]
- aesrLanguage :: Lens' AnalyzeEntitySentimentResponse (Maybe Text)
- data AnalyzeSyntaxResponse
- analyzeSyntaxResponse :: AnalyzeSyntaxResponse
- aTokens :: Lens' AnalyzeSyntaxResponse [Token]
- aSentences :: Lens' AnalyzeSyntaxResponse [Sentence]
- aLanguage :: Lens' AnalyzeSyntaxResponse (Maybe Text)
- data EntityMetadata
- entityMetadata :: HashMap Text Text -> EntityMetadata
- emAddtional :: Lens' EntityMetadata (HashMap Text Text)
- data PartOfSpeechAspect
- data ClassifyTextResponse
- classifyTextResponse :: ClassifyTextResponse
- ctrCategories :: Lens' ClassifyTextResponse [ClassificationCategory]
- data PartOfSpeech
- partOfSpeech :: PartOfSpeech
- posProper :: Lens' PartOfSpeech (Maybe PartOfSpeechProper)
- posTag :: Lens' PartOfSpeech (Maybe PartOfSpeechTag)
- posPerson :: Lens' PartOfSpeech (Maybe PartOfSpeechPerson)
- posAspect :: Lens' PartOfSpeech (Maybe PartOfSpeechAspect)
- posCase :: Lens' PartOfSpeech (Maybe PartOfSpeechCase)
- posGender :: Lens' PartOfSpeech (Maybe PartOfSpeechGender)
- posReciprocity :: Lens' PartOfSpeech (Maybe PartOfSpeechReciprocity)
- posNumber :: Lens' PartOfSpeech (Maybe PartOfSpeechNumber)
- posVoice :: Lens' PartOfSpeech (Maybe PartOfSpeechVoice)
- posForm :: Lens' PartOfSpeech (Maybe PartOfSpeechForm)
- posTense :: Lens' PartOfSpeech (Maybe PartOfSpeechTense)
- posMood :: Lens' PartOfSpeech (Maybe PartOfSpeechMood)
- data PartOfSpeechReciprocity
- data PartOfSpeechGender
- data AnalyzeSentimentRequestEncodingType
- data EntityMentionType
- data Sentence
- sentence :: Sentence
- sSentiment :: Lens' Sentence (Maybe Sentiment)
- sText :: Lens' Sentence (Maybe TextSpan)
Service Configuration
languageService :: ServiceConfig Source #
Default request referring to version v1
of the Cloud Natural Language API. This contains the host and root path used as a starting point for constructing service requests.
OAuth Scopes
cloudLanguageScope :: Proxy '["https://www.googleapis.com/auth/cloud-language"] Source #
Apply machine learning models to reveal the structure and meaning of text
cloudPlatformScope :: Proxy '["https://www.googleapis.com/auth/cloud-platform"] Source #
View and manage your data across Google Cloud Platform services
API Declaration
type LanguageAPI = DocumentsAnalyzeSyntaxResource :<|> (DocumentsClassifyTextResource :<|> (DocumentsAnnotateTextResource :<|> (DocumentsAnalyzeEntitySentimentResource :<|> (DocumentsAnalyzeSentimentResource :<|> DocumentsAnalyzeEntitiesResource)))) Source #
Represents the entirety of the methods and resources available for the Cloud Natural Language API service.
Resources
language.documents.analyzeEntities
language.documents.analyzeEntitySentiment
language.documents.analyzeSentiment
language.documents.analyzeSyntax
language.documents.annotateText
language.documents.classifyText
Types
AnalyzeSyntaxRequest
data AnalyzeSyntaxRequest Source #
The syntax analysis request message.
See: analyzeSyntaxRequest
smart constructor.
Instances
analyzeSyntaxRequest :: AnalyzeSyntaxRequest Source #
Creates a value of AnalyzeSyntaxRequest
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
asrEncodingType :: Lens' AnalyzeSyntaxRequest (Maybe AnalyzeSyntaxRequestEncodingType) Source #
The encoding type used by the API to calculate offsets.
asrDocument :: Lens' AnalyzeSyntaxRequest (Maybe Document) Source #
Input document.
DependencyEdge
data DependencyEdge Source #
Represents dependency parse tree information for a token. (For more information on dependency labels, see http://www.aclweb.org/anthology/P13-2017
See: dependencyEdge
smart constructor.
Instances
dependencyEdge :: DependencyEdge Source #
Creates a value of DependencyEdge
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
deHeadTokenIndex :: Lens' DependencyEdge (Maybe Int32) Source #
Represents the head of this token in the dependency tree. This is the index of the token which has an arc going to this token. The index is the position of the token in the array of tokens returned by the API method. If this token is a root token, then the `head_token_index` is its own index.
deLabel :: Lens' DependencyEdge (Maybe DependencyEdgeLabel) Source #
The parse label for the token.
ClassifyTextRequest
data ClassifyTextRequest Source #
The document classification request message.
See: classifyTextRequest
smart constructor.
Instances
classifyTextRequest :: ClassifyTextRequest Source #
Creates a value of ClassifyTextRequest
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
ctrDocument :: Lens' ClassifyTextRequest (Maybe Document) Source #
Input document.
Status
The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by gRPC. The error model is designed to be: - Simple to use and understand for most users - Flexible enough to meet unexpected needs # Overview The `Status` message contains three pieces of data: error code, error message, and error details. The error code should be an enum value of google.rpc.Code, but it may accept additional error codes if needed. The error message should be a developer-facing English message that helps developers *understand* and *resolve* the error. If a localized user-facing error message is needed, put the localized message in the error details or localize it in the client. The optional error details may contain arbitrary information about the error. There is a predefined set of error detail types in the package `google.rpc` that can be used for common error conditions. # Language mapping The `Status` message is the logical representation of the error model, but it is not necessarily the actual wire format. When the `Status` message is exposed in different client libraries and different wire protocols, it can be mapped differently. For example, it will likely be mapped to some exceptions in Java, but more likely mapped to some error codes in C. # Other uses The error model and the `Status` message can be used in a variety of environments, either with or without APIs, to provide a consistent developer experience across different environments. Example uses of this error model include: - Partial errors. If a service needs to return partial errors to the client, it may embed the `Status` in the normal response to indicate the partial errors. - Workflow errors. A typical workflow has multiple steps. Each step may have a `Status` message for error reporting. - Batch operations. If a client uses batch request and batch response, the `Status` message should be used directly inside batch response, one for each error sub-response. - Asynchronous operations. If an API call embeds asynchronous operation results in its response, the status of those operations should be represented directly using the `Status` message. - Logging. If some API errors are stored in logs, the message `Status` could be used directly after any stripping needed for security/privacy reasons.
See: status
smart constructor.
Instances
Eq Status Source # | |
Data Status Source # | |
Defined in Network.Google.Language.Types.Product gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Status -> c Status # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Status # toConstr :: Status -> Constr # dataTypeOf :: Status -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Status) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Status) # gmapT :: (forall b. Data b => b -> b) -> Status -> Status # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Status -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Status -> r # gmapQ :: (forall d. Data d => d -> u) -> Status -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Status -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Status -> m Status # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Status -> m Status # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Status -> m Status # | |
Show Status Source # | |
Generic Status Source # | |
ToJSON Status Source # | |
Defined in Network.Google.Language.Types.Product | |
FromJSON Status Source # | |
type Rep Status Source # | |
Defined in Network.Google.Language.Types.Product type Rep Status = D1 (MetaData "Status" "Network.Google.Language.Types.Product" "gogol-language-0.4.0-5pnSmGql6DrGvyDSKlfn7G" False) (C1 (MetaCons "Status'" PrefixI True) (S1 (MetaSel (Just "_sDetails") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [StatusDetailsItem])) :*: (S1 (MetaSel (Just "_sCode") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int32))) :*: S1 (MetaSel (Just "_sMessage") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))))) |
sDetails :: Lens' Status [StatusDetailsItem] Source #
A list of messages that carry the error details. There is a common set of message types for APIs to use.
sCode :: Lens' Status (Maybe Int32) Source #
The status code, which should be an enum value of google.rpc.Code.
sMessage :: Lens' Status (Maybe Text) Source #
A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
PartOfSpeechProper
data PartOfSpeechProper Source #
The grammatical properness.
ProperUnknown |
|
Proper |
|
NotProper |
|
Instances
PartOfSpeechTag
data PartOfSpeechTag Source #
The part of speech tag.
Unknown |
|
Adj |
|
Adp |
|
Adv |
|
Conj |
|
Det |
|
Noun |
|
Num |
|
Pron |
|
Prt |
|
Punct |
|
Verb |
|
X |
|
Affix |
|
Instances
Sentiment
Represents the feeling associated with the entire text or entities in the text.
See: sentiment
smart constructor.
Instances
Eq Sentiment Source # | |
Data Sentiment Source # | |
Defined in Network.Google.Language.Types.Product gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sentiment -> c Sentiment # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Sentiment # toConstr :: Sentiment -> Constr # dataTypeOf :: Sentiment -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Sentiment) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sentiment) # gmapT :: (forall b. Data b => b -> b) -> Sentiment -> Sentiment # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sentiment -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sentiment -> r # gmapQ :: (forall d. Data d => d -> u) -> Sentiment -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sentiment -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sentiment -> m Sentiment # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sentiment -> m Sentiment # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sentiment -> m Sentiment # | |
Show Sentiment Source # | |
Generic Sentiment Source # | |
ToJSON Sentiment Source # | |
Defined in Network.Google.Language.Types.Product | |
FromJSON Sentiment Source # | |
type Rep Sentiment Source # | |
Defined in Network.Google.Language.Types.Product type Rep Sentiment = D1 (MetaData "Sentiment" "Network.Google.Language.Types.Product" "gogol-language-0.4.0-5pnSmGql6DrGvyDSKlfn7G" False) (C1 (MetaCons "Sentiment'" PrefixI True) (S1 (MetaSel (Just "_sScore") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Double))) :*: S1 (MetaSel (Just "_sMagnitude") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Double))))) |
sentiment :: Sentiment Source #
Creates a value of Sentiment
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
sScore :: Lens' Sentiment (Maybe Double) Source #
Sentiment score between -1.0 (negative sentiment) and 1.0 (positive sentiment).
sMagnitude :: Lens' Sentiment (Maybe Double) Source #
A non-negative number in the [0, +inf) range, which represents the absolute magnitude of sentiment regardless of score (positive or negative).
DocumentType
data DocumentType Source #
Required. If the type is not set or is `TYPE_UNSPECIFIED`, returns an `INVALID_ARGUMENT` error.
TypeUnspecified |
|
PlainText |
|
HTML |
|
Instances
AnalyzeSyntaxRequestEncodingType
data AnalyzeSyntaxRequestEncodingType Source #
The encoding type used by the API to calculate offsets.
None |
|
UTF8 |
|
UTF16 |
|
UTF32 |
|
Instances
AnalyzeEntitySentimentRequestEncodingType
data AnalyzeEntitySentimentRequestEncodingType Source #
The encoding type used by the API to calculate offsets.
AESRETNone |
|
AESRETUTF8 |
|
AESRETUTF16 |
|
AESRETUTF32 |
|
Instances
DependencyEdgeLabel
data DependencyEdgeLabel Source #
The parse label for the token.
DELUnknown |
|
DELAbbrev |
|
DELAcomp |
|
DELAdvcl |
|
DELAdvmod |
|
DELAmod |
|
DELAppos |
|
DELAttr |
|
DELAux |
|
DELAuxpass |
|
DELCC |
|
DELCcomp |
|
DELConj |
|
DELCsubj |
|
DELCsubjpass |
|
DELDep |
|
DELDet |
|
DELDiscourse |
|
DELDobj |
|
DELExpl |
|
DELGoeswith |
|
DELIobj |
|
DELMark |
|
DELMwe |
|
DELMwv |
|
DELNeg |
|
DELNN |
|
DELNpadvmod |
|
DELNsubj |
|
DELNsubjpass |
|
DELNum |
|
DELNumber |
|
DELP |
|
DELParataxis |
|
DELPartmod |
|
DELPcomp |
|
DELPobj |
|
DELPoss |
|
DELPostneg |
|
DELPrecomp |
|
DELPreconj |
|
DELPredet |
|
DELPref |
|
DELPrep |
|
DELPronl |
|
DELPrt |
|
DELPS |
|
DELQuantmod |
|
DELRcmod |
|
DELRcmodrel |
|
DELRdrop |
|
DELRef |
|
DELRemnant |
|
DELReparandum |
|
DELRoot |
|
DELSnum |
|
DELSuff |
|
DELTmod |
|
DELTopic |
|
DELVMod |
|
DELVocative |
|
DELXcomp |
|
DELSuffix |
|
DELTitle |
|
DELAdvphmod |
|
DELAuxcaus |
|
DELAuxvv |
|
DELDtmod |
|
DELForeign |
|
DELKW |
|
DELList |
|
DELNomc |
|
DELNomcsubj |
|
DELNomcsubjpass |
|
DELNumc |
|
DELCop |
|
DELDislocated |
|
DELAsp |
|
DELGmod |
|
DELGobj |
|
DELInfmod |
|
DELMes |
|
DELNcomp |
|
Instances
PartOfSpeechVoice
data PartOfSpeechVoice Source #
The grammatical voice.
VoiceUnknown |
|
Active |
|
Causative |
|
Passive |
|
Instances
PartOfSpeechForm
data PartOfSpeechForm Source #
The grammatical form.
FormUnknown |
|
Adnomial |
|
Auxiliary |
|
Complementizer |
|
FinalEnding |
|
Gerund |
|
Realis |
|
Irrealis |
|
Short |
|
Long |
|
Order |
|
Specific |
|
Instances
PartOfSpeechPerson
data PartOfSpeechPerson Source #
The grammatical person.
PersonUnknown |
|
First |
|
Second |
|
Third |
|
ReflexivePerson |
|
Instances
Token
Represents the smallest syntactic building block of the text.
See: token
smart constructor.
Instances
Eq Token Source # | |
Data Token Source # | |
Defined in Network.Google.Language.Types.Product gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Token -> c Token # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Token # dataTypeOf :: Token -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Token) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Token) # gmapT :: (forall b. Data b => b -> b) -> Token -> Token # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r # gmapQ :: (forall d. Data d => d -> u) -> Token -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Token -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Token -> m Token # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Token -> m Token # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Token -> m Token # | |
Show Token Source # | |
Generic Token Source # | |
ToJSON Token Source # | |
Defined in Network.Google.Language.Types.Product | |
FromJSON Token Source # | |
type Rep Token Source # | |
Defined in Network.Google.Language.Types.Product type Rep Token = D1 (MetaData "Token" "Network.Google.Language.Types.Product" "gogol-language-0.4.0-5pnSmGql6DrGvyDSKlfn7G" False) (C1 (MetaCons "Token'" PrefixI True) ((S1 (MetaSel (Just "_tDependencyEdge") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe DependencyEdge)) :*: S1 (MetaSel (Just "_tText") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe TextSpan))) :*: (S1 (MetaSel (Just "_tLemma") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)) :*: S1 (MetaSel (Just "_tPartOfSpeech") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe PartOfSpeech))))) |
Creates a value of Token
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
tDependencyEdge :: Lens' Token (Maybe DependencyEdge) Source #
Dependency tree parse for this token.
tPartOfSpeech :: Lens' Token (Maybe PartOfSpeech) Source #
Parts of speech tag for this token.
EntityType
data EntityType Source #
The entity type.
ETUnknown |
|
ETPerson |
|
ETLocation |
|
ETOrganization |
|
ETEvent |
|
ETWorkOfArt |
|
ETConsumerGood |
|
ETOther |
|
Instances
StatusDetailsItem
data StatusDetailsItem Source #
Instances
Creates a value of StatusDetailsItem
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
sdiAddtional :: Lens' StatusDetailsItem (HashMap Text JSONValue) Source #
Properties of the object. Contains field 'type with type URL.
ClassificationCategory
data ClassificationCategory Source #
Represents a category returned from the text classifier.
See: classificationCategory
smart constructor.
Instances
classificationCategory :: ClassificationCategory Source #
Creates a value of ClassificationCategory
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
ccConfidence :: Lens' ClassificationCategory (Maybe Double) Source #
The classifier's confidence of the category. Number represents how certain the classifier is that this category represents the given text.
ccName :: Lens' ClassificationCategory (Maybe Text) Source #
The name of the category representing the document, from the predefined taxonomy.
AnnotateTextRequest
data AnnotateTextRequest Source #
The request message for the text annotation API, which can perform multiple analysis types (sentiment, entities, and syntax) in one call.
See: annotateTextRequest
smart constructor.
Instances
annotateTextRequest :: AnnotateTextRequest Source #
Creates a value of AnnotateTextRequest
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
atrEncodingType :: Lens' AnnotateTextRequest (Maybe AnnotateTextRequestEncodingType) Source #
The encoding type used by the API to calculate offsets.
atrFeatures :: Lens' AnnotateTextRequest (Maybe Features) Source #
The enabled features.
atrDocument :: Lens' AnnotateTextRequest (Maybe Document) Source #
Input document.
EntityMention
data EntityMention Source #
Represents a mention for an entity in the text. Currently, proper noun mentions are supported.
See: entityMention
smart constructor.
Instances
entityMention :: EntityMention Source #
Creates a value of EntityMention
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
emSentiment :: Lens' EntityMention (Maybe Sentiment) Source #
For calls to AnalyzeEntitySentiment or if AnnotateTextRequest.Features.extract_entity_sentiment is set to true, this field will contain the sentiment expressed for this mention of the entity in the provided document.
emType :: Lens' EntityMention (Maybe EntityMentionType) Source #
The type of the entity mention.
TextSpan
Represents an output piece of text.
See: textSpan
smart constructor.
Instances
Eq TextSpan Source # | |
Data TextSpan Source # | |
Defined in Network.Google.Language.Types.Product gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TextSpan -> c TextSpan # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TextSpan # toConstr :: TextSpan -> Constr # dataTypeOf :: TextSpan -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TextSpan) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TextSpan) # gmapT :: (forall b. Data b => b -> b) -> TextSpan -> TextSpan # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TextSpan -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TextSpan -> r # gmapQ :: (forall d. Data d => d -> u) -> TextSpan -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TextSpan -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TextSpan -> m TextSpan # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TextSpan -> m TextSpan # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TextSpan -> m TextSpan # | |
Show TextSpan Source # | |
Generic TextSpan Source # | |
ToJSON TextSpan Source # | |
Defined in Network.Google.Language.Types.Product | |
FromJSON TextSpan Source # | |
type Rep TextSpan Source # | |
Defined in Network.Google.Language.Types.Product type Rep TextSpan = D1 (MetaData "TextSpan" "Network.Google.Language.Types.Product" "gogol-language-0.4.0-5pnSmGql6DrGvyDSKlfn7G" False) (C1 (MetaCons "TextSpan'" PrefixI True) (S1 (MetaSel (Just "_tsBeginOffSet") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int32))) :*: S1 (MetaSel (Just "_tsContent") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)))) |
Creates a value of TextSpan
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
tsBeginOffSet :: Lens' TextSpan (Maybe Int32) Source #
The API calculates the beginning offset of the content in the original document according to the EncodingType specified in the API request.
AnalyzeEntitySentimentRequest
data AnalyzeEntitySentimentRequest Source #
The entity-level sentiment analysis request message.
See: analyzeEntitySentimentRequest
smart constructor.
Instances
analyzeEntitySentimentRequest :: AnalyzeEntitySentimentRequest Source #
Creates a value of AnalyzeEntitySentimentRequest
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
aesrEncodingType :: Lens' AnalyzeEntitySentimentRequest (Maybe AnalyzeEntitySentimentRequestEncodingType) Source #
The encoding type used by the API to calculate offsets.
aesrDocument :: Lens' AnalyzeEntitySentimentRequest (Maybe Document) Source #
Input document.
AnnotateTextResponse
data AnnotateTextResponse Source #
The text annotations response message.
See: annotateTextResponse
smart constructor.
Instances
annotateTextResponse :: AnnotateTextResponse Source #
Creates a value of AnnotateTextResponse
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
atrEntities :: Lens' AnnotateTextResponse [Entity] Source #
Entities, along with their semantic information, in the input document. Populated if the user enables AnnotateTextRequest.Features.extract_entities.
atrTokens :: Lens' AnnotateTextResponse [Token] Source #
Tokens, along with their syntactic information, in the input document. Populated if the user enables AnnotateTextRequest.Features.extract_syntax.
atrDocumentSentiment :: Lens' AnnotateTextResponse (Maybe Sentiment) Source #
The overall sentiment for the document. Populated if the user enables AnnotateTextRequest.Features.extract_document_sentiment.
atrCategories :: Lens' AnnotateTextResponse [ClassificationCategory] Source #
Categories identified in the input document.
atrSentences :: Lens' AnnotateTextResponse [Sentence] Source #
Sentences in the input document. Populated if the user enables AnnotateTextRequest.Features.extract_syntax.
atrLanguage :: Lens' AnnotateTextResponse (Maybe Text) Source #
The language of the text, which will be the same as the language specified in the request or, if not specified, the automatically-detected language. See Document.language field for more details.
PartOfSpeechTense
data PartOfSpeechTense Source #
The grammatical tense.
TenseUnknown |
|
ConditionalTense |
|
Future |
|
Past |
|
Present |
|
Imperfect |
|
Pluperfect |
|
Instances
Features
All available features for sentiment, syntax, and semantic analysis. Setting each one to true will enable that specific analysis for the input.
See: features
smart constructor.
Instances
Eq Features Source # | |
Data Features Source # | |
Defined in Network.Google.Language.Types.Product gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Features -> c Features # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Features # toConstr :: Features -> Constr # dataTypeOf :: Features -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Features) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Features) # gmapT :: (forall b. Data b => b -> b) -> Features -> Features # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Features -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Features -> r # gmapQ :: (forall d. Data d => d -> u) -> Features -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Features -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Features -> m Features # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Features -> m Features # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Features -> m Features # | |
Show Features Source # | |
Generic Features Source # | |
ToJSON Features Source # | |
Defined in Network.Google.Language.Types.Product | |
FromJSON Features Source # | |
type Rep Features Source # | |
Defined in Network.Google.Language.Types.Product type Rep Features = D1 (MetaData "Features" "Network.Google.Language.Types.Product" "gogol-language-0.4.0-5pnSmGql6DrGvyDSKlfn7G" False) (C1 (MetaCons "Features'" PrefixI True) ((S1 (MetaSel (Just "_fExtractSyntax") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Bool)) :*: S1 (MetaSel (Just "_fExtractDocumentSentiment") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Bool))) :*: (S1 (MetaSel (Just "_fClassifyText") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Bool)) :*: (S1 (MetaSel (Just "_fExtractEntitySentiment") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Bool)) :*: S1 (MetaSel (Just "_fExtractEntities") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Bool)))))) |
Creates a value of Features
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
fExtractEntitySentiment :: Lens' Features (Maybe Bool) Source #
Extract entities and their associated sentiment.
Document
############################################################### Represents the input to API methods.
See: document
smart constructor.
Instances
Eq Document Source # | |
Data Document Source # | |
Defined in Network.Google.Language.Types.Product gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Document -> c Document # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Document # toConstr :: Document -> Constr # dataTypeOf :: Document -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Document) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Document) # gmapT :: (forall b. Data b => b -> b) -> Document -> Document # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Document -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Document -> r # gmapQ :: (forall d. Data d => d -> u) -> Document -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Document -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Document -> m Document # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Document -> m Document # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Document -> m Document # | |
Show Document Source # | |
Generic Document Source # | |
ToJSON Document Source # | |
Defined in Network.Google.Language.Types.Product | |
FromJSON Document Source # | |
type Rep Document Source # | |
Defined in Network.Google.Language.Types.Product type Rep Document = D1 (MetaData "Document" "Network.Google.Language.Types.Product" "gogol-language-0.4.0-5pnSmGql6DrGvyDSKlfn7G" False) (C1 (MetaCons "Document'" PrefixI True) ((S1 (MetaSel (Just "_dContent") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)) :*: S1 (MetaSel (Just "_dLanguage") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) :*: (S1 (MetaSel (Just "_dGcsContentURI") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)) :*: S1 (MetaSel (Just "_dType") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe DocumentType))))) |
Creates a value of Document
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
dContent :: Lens' Document (Maybe Text) Source #
The content of the input in string format. Cloud audit logging exempt since it is based on user data.
dLanguage :: Lens' Document (Maybe Text) Source #
The language of the document (if not specified, the language is automatically detected). Both ISO and BCP-47 language codes are accepted. Language Support lists currently supported languages for each API method. If the language (either specified by the caller or automatically detected) is not supported by the called API method, an `INVALID_ARGUMENT` error is returned.
dGcsContentURI :: Lens' Document (Maybe Text) Source #
The Google Cloud Storage URI where the file content is located. This URI must be of the form: gs://bucket_name/object_name. For more details, see https://cloud.google.com/storage/docs/reference-uris. NOTE: Cloud Storage object versioning is not supported.
dType :: Lens' Document (Maybe DocumentType) Source #
Required. If the type is not set or is `TYPE_UNSPECIFIED`, returns an `INVALID_ARGUMENT` error.
PartOfSpeechMood
data PartOfSpeechMood Source #
The grammatical mood.
MoodUnknown |
|
ConditionalMood |
|
Imperative |
|
Indicative |
|
Interrogative |
|
Jussive |
|
Subjunctive |
|
Instances
PartOfSpeechCase
data PartOfSpeechCase Source #
The grammatical case.
CaseUnknown |
|
Accusative |
|
Adverbial |
|
Complementive |
|
Dative |
|
Genitive |
|
Instrumental |
|
Locative |
|
Nominative |
|
Oblique |
|
Partitive |
|
PrePositional |
|
ReflexiveCase |
|
RelativeCase |
|
Vocative |
|
Instances
AnalyzeSentimentRequest
data AnalyzeSentimentRequest Source #
The sentiment analysis request message.
See: analyzeSentimentRequest
smart constructor.
Instances
analyzeSentimentRequest :: AnalyzeSentimentRequest Source #
Creates a value of AnalyzeSentimentRequest
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
aEncodingType :: Lens' AnalyzeSentimentRequest (Maybe AnalyzeSentimentRequestEncodingType) Source #
The encoding type used by the API to calculate sentence offsets.
Xgafv
V1 error format.
Instances
AnalyzeEntitiesResponse
data AnalyzeEntitiesResponse Source #
The entity analysis response message.
See: analyzeEntitiesResponse
smart constructor.
Instances
analyzeEntitiesResponse :: AnalyzeEntitiesResponse Source #
Creates a value of AnalyzeEntitiesResponse
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
aerEntities :: Lens' AnalyzeEntitiesResponse [Entity] Source #
The recognized entities in the input document.
aerLanguage :: Lens' AnalyzeEntitiesResponse (Maybe Text) Source #
The language of the text, which will be the same as the language specified in the request or, if not specified, the automatically-detected language. See Document.language field for more details.
AnnotateTextRequestEncodingType
data AnnotateTextRequestEncodingType Source #
The encoding type used by the API to calculate offsets.
ATRETNone |
|
ATRETUTF8 |
|
ATRETUTF16 |
|
ATRETUTF32 |
|
Instances
PartOfSpeechNumber
data PartOfSpeechNumber Source #
The grammatical number.
NumberUnknown |
|
Singular |
|
Plural |
|
Dual |
|
Instances
AnalyzeSentimentResponse
data AnalyzeSentimentResponse Source #
The sentiment analysis response message.
See: analyzeSentimentResponse
smart constructor.
Instances
analyzeSentimentResponse :: AnalyzeSentimentResponse Source #
Creates a value of AnalyzeSentimentResponse
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
asrDocumentSentiment :: Lens' AnalyzeSentimentResponse (Maybe Sentiment) Source #
The overall sentiment of the input document.
asrSentences :: Lens' AnalyzeSentimentResponse [Sentence] Source #
The sentiment for all the sentences in the document.
asrLanguage :: Lens' AnalyzeSentimentResponse (Maybe Text) Source #
The language of the text, which will be the same as the language specified in the request or, if not specified, the automatically-detected language. See Document.language field for more details.
AnalyzeEntitiesRequest
data AnalyzeEntitiesRequest Source #
The entity analysis request message.
See: analyzeEntitiesRequest
smart constructor.
Instances
analyzeEntitiesRequest :: AnalyzeEntitiesRequest Source #
Creates a value of AnalyzeEntitiesRequest
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
aerEncodingType :: Lens' AnalyzeEntitiesRequest (Maybe AnalyzeEntitiesRequestEncodingType) Source #
The encoding type used by the API to calculate offsets.
aerDocument :: Lens' AnalyzeEntitiesRequest (Maybe Document) Source #
Input document.
AnalyzeEntitiesRequestEncodingType
data AnalyzeEntitiesRequestEncodingType Source #
The encoding type used by the API to calculate offsets.
AERETNone |
|
AERETUTF8 |
|
AERETUTF16 |
|
AERETUTF32 |
|
Instances
Entity
Represents a phrase in the text that is a known entity, such as a person, an organization, or location. The API associates information, such as salience and mentions, with entities.
See: entity
smart constructor.
Instances
eSentiment :: Lens' Entity (Maybe Sentiment) Source #
For calls to AnalyzeEntitySentiment or if AnnotateTextRequest.Features.extract_entity_sentiment is set to true, this field will contain the aggregate sentiment expressed for this entity in the provided document.
eSalience :: Lens' Entity (Maybe Double) Source #
The salience score associated with the entity in the [0, 1.0] range. The salience score for an entity provides information about the importance or centrality of that entity to the entire document text. Scores closer to 0 are less salient, while scores closer to 1.0 are highly salient.
eMetadata :: Lens' Entity (Maybe EntityMetadata) Source #
Metadata associated with the entity. Currently, Wikipedia URLs and Knowledge Graph MIDs are provided, if available. The associated keys are "wikipedia_url" and "mid", respectively.
eMentions :: Lens' Entity [EntityMention] Source #
The mentions of this entity in the input document. The API currently supports proper noun mentions.
AnalyzeEntitySentimentResponse
data AnalyzeEntitySentimentResponse Source #
The entity-level sentiment analysis response message.
See: analyzeEntitySentimentResponse
smart constructor.
Instances
analyzeEntitySentimentResponse :: AnalyzeEntitySentimentResponse Source #
Creates a value of AnalyzeEntitySentimentResponse
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
aesrEntities :: Lens' AnalyzeEntitySentimentResponse [Entity] Source #
The recognized entities in the input document with associated sentiments.
aesrLanguage :: Lens' AnalyzeEntitySentimentResponse (Maybe Text) Source #
The language of the text, which will be the same as the language specified in the request or, if not specified, the automatically-detected language. See Document.language field for more details.
AnalyzeSyntaxResponse
data AnalyzeSyntaxResponse Source #
The syntax analysis response message.
See: analyzeSyntaxResponse
smart constructor.
Instances
analyzeSyntaxResponse :: AnalyzeSyntaxResponse Source #
Creates a value of AnalyzeSyntaxResponse
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
aTokens :: Lens' AnalyzeSyntaxResponse [Token] Source #
Tokens, along with their syntactic information, in the input document.
aSentences :: Lens' AnalyzeSyntaxResponse [Sentence] Source #
Sentences in the input document.
aLanguage :: Lens' AnalyzeSyntaxResponse (Maybe Text) Source #
The language of the text, which will be the same as the language specified in the request or, if not specified, the automatically-detected language. See Document.language field for more details.
EntityMetadata
data EntityMetadata Source #
Metadata associated with the entity. Currently, Wikipedia URLs and Knowledge Graph MIDs are provided, if available. The associated keys are "wikipedia_url" and "mid", respectively.
See: entityMetadata
smart constructor.
Instances
Creates a value of EntityMetadata
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
PartOfSpeechAspect
data PartOfSpeechAspect Source #
The grammatical aspect.
AspectUnknown |
|
Perfective |
|
Imperfective |
|
Progressive |
|
Instances
ClassifyTextResponse
data ClassifyTextResponse Source #
The document classification response message.
See: classifyTextResponse
smart constructor.
Instances
classifyTextResponse :: ClassifyTextResponse Source #
Creates a value of ClassifyTextResponse
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired:
ctrCategories :: Lens' ClassifyTextResponse [ClassificationCategory] Source #
Categories representing the input document.
PartOfSpeech
data PartOfSpeech Source #
Represents part of speech information for a token. Parts of speech are as defined in http://www.lrec-conf.org/proceedings/lrec2012/pdf/274_Paper.pdf
See: partOfSpeech
smart constructor.
Instances
posProper :: Lens' PartOfSpeech (Maybe PartOfSpeechProper) Source #
The grammatical properness.
posTag :: Lens' PartOfSpeech (Maybe PartOfSpeechTag) Source #
The part of speech tag.
posPerson :: Lens' PartOfSpeech (Maybe PartOfSpeechPerson) Source #
The grammatical person.
posAspect :: Lens' PartOfSpeech (Maybe PartOfSpeechAspect) Source #
The grammatical aspect.
posCase :: Lens' PartOfSpeech (Maybe PartOfSpeechCase) Source #
The grammatical case.
posGender :: Lens' PartOfSpeech (Maybe PartOfSpeechGender) Source #
The grammatical gender.
posReciprocity :: Lens' PartOfSpeech (Maybe PartOfSpeechReciprocity) Source #
The grammatical reciprocity.
posNumber :: Lens' PartOfSpeech (Maybe PartOfSpeechNumber) Source #
The grammatical number.
posVoice :: Lens' PartOfSpeech (Maybe PartOfSpeechVoice) Source #
The grammatical voice.
posForm :: Lens' PartOfSpeech (Maybe PartOfSpeechForm) Source #
The grammatical form.
posTense :: Lens' PartOfSpeech (Maybe PartOfSpeechTense) Source #
The grammatical tense.
posMood :: Lens' PartOfSpeech (Maybe PartOfSpeechMood) Source #
The grammatical mood.
PartOfSpeechReciprocity
data PartOfSpeechReciprocity Source #
The grammatical reciprocity.
ReciprocityUnknown |
|
Reciprocal |
|
NonReciprocal |
|
Instances
PartOfSpeechGender
data PartOfSpeechGender Source #
The grammatical gender.
GenderUnknown |
|
Feminine |
|
Masculine |
|
Neuter |
|
Instances
AnalyzeSentimentRequestEncodingType
data AnalyzeSentimentRequestEncodingType Source #
The encoding type used by the API to calculate sentence offsets.
ASRETNone |
|
ASRETUTF8 |
|
ASRETUTF16 |
|
ASRETUTF32 |
|
Instances
EntityMentionType
data EntityMentionType Source #
The type of the entity mention.
EMTTypeUnknown |
|
EMTProper |
|
EMTCommon |
|
Instances
Sentence
Represents a sentence in the input document.
See: sentence
smart constructor.
Instances
Eq Sentence Source # | |
Data Sentence Source # | |
Defined in Network.Google.Language.Types.Product gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sentence -> c Sentence # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Sentence # toConstr :: Sentence -> Constr # dataTypeOf :: Sentence -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Sentence) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sentence) # gmapT :: (forall b. Data b => b -> b) -> Sentence -> Sentence # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sentence -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sentence -> r # gmapQ :: (forall d. Data d => d -> u) -> Sentence -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sentence -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sentence -> m Sentence # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sentence -> m Sentence # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sentence -> m Sentence # | |
Show Sentence Source # | |
Generic Sentence Source # | |
ToJSON Sentence Source # | |
Defined in Network.Google.Language.Types.Product | |
FromJSON Sentence Source # | |
type Rep Sentence Source # | |
Defined in Network.Google.Language.Types.Product type Rep Sentence = D1 (MetaData "Sentence" "Network.Google.Language.Types.Product" "gogol-language-0.4.0-5pnSmGql6DrGvyDSKlfn7G" False) (C1 (MetaCons "Sentence'" PrefixI True) (S1 (MetaSel (Just "_sSentiment") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Sentiment)) :*: S1 (MetaSel (Just "_sText") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe TextSpan)))) |
Creates a value of Sentence
with the minimum fields required to make a request.
Use one of the following lenses to modify other fields as desired: