Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace types

Index

Enumerations

Type aliases

Type aliases

AceResult

AceResult: { __typename?: "ACEResult"; result?: Maybe<Scalars["String"]> }

Output type

Type declaration

  • Optional __typename?: "ACEResult"
  • Optional result?: Maybe<Scalars["String"]>

    APE output

Answer

Answer: { __typename?: "Answer"; answer: Scalars["String"]; score: Scalars["Float"] }

Answer along with confidence score

Type declaration

  • Optional __typename?: "Answer"
  • answer: Scalars["String"]

    Answer based on the given context

  • score: Scalars["Float"]

    Confidence in the prediction

AnswerQuestionQuery

AnswerQuestionQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "QA_Result" } & { answers: { __typename?: "Answer" } & Pick<Answer, "answer" | "score"> }> }

AnswerQuestionQueryVariables

AnswerQuestionQueryVariables: Exact<{ context: Scalars["String"]; input: Scalars["String"] }>

App_Status_Comparison_Exp

App_Status_Comparison_Exp: { _eq?: Maybe<Scalars["app_status"]>; _gt?: Maybe<Scalars["app_status"]>; _gte?: Maybe<Scalars["app_status"]>; _in?: Maybe<Scalars["app_status"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["app_status"]>; _lte?: Maybe<Scalars["app_status"]>; _neq?: Maybe<Scalars["app_status"]>; _nin?: Maybe<Scalars["app_status"][]> }

Boolean expression to compare columns of type "app_status". All fields are combined with logical 'AND'.

Type declaration

Apps

Apps: { __typename?: "apps"; conversations: Conversations[]; conversations_aggregate: Conversations_Aggregate; created_at: Scalars["timestamptz"]; developer: Developers; developer_id: Scalars["Int"]; kv_store: Kv_Store[]; kv_store_aggregate: Kv_Store_Aggregate; metadata: Scalars["jsonb"]; object_id: Scalars["Int"]; scope_name?: Maybe<Scalars["String"]>; slug: Scalars["String"]; status: Scalars["app_status"] }

columns and relationships of "apps"

Type declaration

AppsConversationsArgs

AppsConversationsArgs: { distinct_on?: Maybe<Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conversations_Order_By[]>; where?: Maybe<Conversations_Bool_Exp> }

columns and relationships of "apps"

Type declaration

AppsConversations_AggregateArgs

AppsConversations_AggregateArgs: { distinct_on?: Maybe<Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conversations_Order_By[]>; where?: Maybe<Conversations_Bool_Exp> }

columns and relationships of "apps"

Type declaration

AppsKv_StoreArgs

AppsKv_StoreArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

columns and relationships of "apps"

Type declaration

AppsKv_Store_AggregateArgs

AppsKv_Store_AggregateArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

columns and relationships of "apps"

Type declaration

AppsMetadataArgs

AppsMetadataArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "apps"

Type declaration

Apps_Aggregate

Apps_Aggregate: { __typename?: "apps_aggregate"; aggregate?: Maybe<Apps_Aggregate_Fields>; nodes: Apps[] }

aggregated selection of "apps"

Type declaration

Apps_Aggregate_Fields

Apps_Aggregate_Fields: { __typename?: "apps_aggregate_fields"; avg?: Maybe<Apps_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<Apps_Max_Fields>; min?: Maybe<Apps_Min_Fields>; stddev?: Maybe<Apps_Stddev_Fields>; stddev_pop?: Maybe<Apps_Stddev_Pop_Fields>; stddev_samp?: Maybe<Apps_Stddev_Samp_Fields>; sum?: Maybe<Apps_Sum_Fields>; var_pop?: Maybe<Apps_Var_Pop_Fields>; var_samp?: Maybe<Apps_Var_Samp_Fields>; variance?: Maybe<Apps_Variance_Fields> }

aggregate fields of "apps"

Type declaration

Apps_Aggregate_FieldsCountArgs

Apps_Aggregate_FieldsCountArgs: { columns?: Maybe<Apps_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "apps"

Type declaration

Apps_Aggregate_Order_By

order by aggregate values of table "apps"

Type declaration

Apps_Append_Input

Apps_Append_Input: { metadata?: Maybe<Scalars["jsonb"]> }

append existing jsonb value of filtered columns with new jsonb value

Type declaration

Apps_Arr_Rel_Insert_Input

Apps_Arr_Rel_Insert_Input: { data: Apps_Insert_Input[]; on_conflict?: Maybe<Apps_On_Conflict> }

input type for inserting array relation for remote table "apps"

Type declaration

Apps_Avg_Fields

Apps_Avg_Fields: { __typename?: "apps_avg_fields"; developer_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "apps_avg_fields"
  • Optional developer_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Apps_Avg_Order_By

Apps_Avg_Order_By: { developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by avg() on columns of table "apps"

Type declaration

Apps_Bool_Exp

Apps_Bool_Exp: { _and?: Maybe<Apps_Bool_Exp[]>; _not?: Maybe<Apps_Bool_Exp>; _or?: Maybe<Apps_Bool_Exp[]>; conversations?: Maybe<Conversations_Bool_Exp>; created_at?: Maybe<Timestamptz_Comparison_Exp>; developer?: Maybe<Developers_Bool_Exp>; developer_id?: Maybe<Int_Comparison_Exp>; kv_store?: Maybe<Kv_Store_Bool_Exp>; metadata?: Maybe<Jsonb_Comparison_Exp>; object_id?: Maybe<Int_Comparison_Exp>; scope_name?: Maybe<String_Comparison_Exp>; slug?: Maybe<String_Comparison_Exp>; status?: Maybe<App_Status_Comparison_Exp> }

Boolean expression to filter rows from the table "apps". All fields are combined with a logical 'AND'.

Type declaration

Apps_Delete_At_Path_Input

Apps_Delete_At_Path_Input: { metadata?: Maybe<Scalars["String"][]> }

delete the field or element with specified path (for JSON arrays, negative integers count from the end)

Type declaration

Apps_Delete_Elem_Input

Apps_Delete_Elem_Input: { metadata?: Maybe<Scalars["Int"]> }

delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array

Type declaration

Apps_Delete_Key_Input

Apps_Delete_Key_Input: { metadata?: Maybe<Scalars["String"]> }

delete key/value pair or string element. key/value pairs are matched based on their key value

Type declaration

Apps_Inc_Input

Apps_Inc_Input: { developer_id?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]> }

input type for incrementing numeric columns in table "apps"

Type declaration

Apps_Insert_Input

Apps_Insert_Input: { conversations?: Maybe<Conversations_Arr_Rel_Insert_Input>; created_at?: Maybe<Scalars["timestamptz"]>; developer?: Maybe<Developers_Obj_Rel_Insert_Input>; developer_id?: Maybe<Scalars["Int"]>; kv_store?: Maybe<Kv_Store_Arr_Rel_Insert_Input>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]>; slug?: Maybe<Scalars["String"]>; status?: Maybe<Scalars["app_status"]> }

input type for inserting data into table "apps"

Type declaration

Apps_Max_Fields

Apps_Max_Fields: { __typename?: "apps_max_fields"; created_at?: Maybe<Scalars["timestamptz"]>; developer_id?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]>; slug?: Maybe<Scalars["String"]> }

aggregate max on columns

Type declaration

Apps_Max_Order_By

Apps_Max_Order_By: { created_at?: Maybe<Order_By>; developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_name?: Maybe<Order_By>; slug?: Maybe<Order_By> }

order by max() on columns of table "apps"

Type declaration

Apps_Min_Fields

Apps_Min_Fields: { __typename?: "apps_min_fields"; created_at?: Maybe<Scalars["timestamptz"]>; developer_id?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]>; slug?: Maybe<Scalars["String"]> }

aggregate min on columns

Type declaration

Apps_Min_Order_By

Apps_Min_Order_By: { created_at?: Maybe<Order_By>; developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_name?: Maybe<Order_By>; slug?: Maybe<Order_By> }

order by min() on columns of table "apps"

Type declaration

Apps_Mutation_Response

Apps_Mutation_Response: { __typename?: "apps_mutation_response"; affected_rows: Scalars["Int"]; returning: Apps[] }

response of any mutation on the table "apps"

Type declaration

  • Optional __typename?: "apps_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Apps[]

    data from the rows affected by the mutation

Apps_Obj_Rel_Insert_Input

Apps_Obj_Rel_Insert_Input: { data: Apps_Insert_Input; on_conflict?: Maybe<Apps_On_Conflict> }

input type for inserting object relation for remote table "apps"

Type declaration

Apps_On_Conflict

Apps_On_Conflict: { constraint: Apps_Constraint; update_columns: Apps_Update_Column[]; where?: Maybe<Apps_Bool_Exp> }

on conflict condition type for table "apps"

Type declaration

Apps_Order_By

Apps_Order_By: { conversations_aggregate?: Maybe<Conversations_Aggregate_Order_By>; created_at?: Maybe<Order_By>; developer?: Maybe<Developers_Order_By>; developer_id?: Maybe<Order_By>; kv_store_aggregate?: Maybe<Kv_Store_Aggregate_Order_By>; metadata?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_name?: Maybe<Order_By>; slug?: Maybe<Order_By>; status?: Maybe<Order_By> }

Ordering options when selecting data from "apps".

Type declaration

Apps_Prepend_Input

Apps_Prepend_Input: { metadata?: Maybe<Scalars["jsonb"]> }

prepend existing jsonb value of filtered columns with new jsonb value

Type declaration

Apps_Set_Input

Apps_Set_Input: { created_at?: Maybe<Scalars["timestamptz"]>; developer_id?: Maybe<Scalars["Int"]>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]>; slug?: Maybe<Scalars["String"]>; status?: Maybe<Scalars["app_status"]> }

input type for updating data in table "apps"

Type declaration

Apps_Stddev_Fields

Apps_Stddev_Fields: { __typename?: "apps_stddev_fields"; developer_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "apps_stddev_fields"
  • Optional developer_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Apps_Stddev_Order_By

Apps_Stddev_Order_By: { developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by stddev() on columns of table "apps"

Type declaration

Apps_Stddev_Pop_Fields

Apps_Stddev_Pop_Fields: { __typename?: "apps_stddev_pop_fields"; developer_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "apps_stddev_pop_fields"
  • Optional developer_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Apps_Stddev_Pop_Order_By

Apps_Stddev_Pop_Order_By: { developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by stddev_pop() on columns of table "apps"

Type declaration

Apps_Stddev_Samp_Fields

Apps_Stddev_Samp_Fields: { __typename?: "apps_stddev_samp_fields"; developer_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "apps_stddev_samp_fields"
  • Optional developer_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Apps_Stddev_Samp_Order_By

Apps_Stddev_Samp_Order_By: { developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by stddev_samp() on columns of table "apps"

Type declaration

Apps_Sum_Fields

Apps_Sum_Fields: { __typename?: "apps_sum_fields"; developer_id?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "apps_sum_fields"
  • Optional developer_id?: Maybe<Scalars["Int"]>
  • Optional object_id?: Maybe<Scalars["Int"]>

Apps_Sum_Order_By

Apps_Sum_Order_By: { developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by sum() on columns of table "apps"

Type declaration

Apps_Var_Pop_Fields

Apps_Var_Pop_Fields: { __typename?: "apps_var_pop_fields"; developer_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "apps_var_pop_fields"
  • Optional developer_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Apps_Var_Pop_Order_By

Apps_Var_Pop_Order_By: { developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by var_pop() on columns of table "apps"

Type declaration

Apps_Var_Samp_Fields

Apps_Var_Samp_Fields: { __typename?: "apps_var_samp_fields"; developer_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "apps_var_samp_fields"
  • Optional developer_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Apps_Var_Samp_Order_By

Apps_Var_Samp_Order_By: { developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by var_samp() on columns of table "apps"

Type declaration

Apps_Variance_Fields

Apps_Variance_Fields: { __typename?: "apps_variance_fields"; developer_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "apps_variance_fields"
  • Optional developer_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Apps_Variance_Order_By

Apps_Variance_Order_By: { developer_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by variance() on columns of table "apps"

Type declaration

Atomic_Data

Atomic_Data: { __typename?: "atomic_data"; event?: Maybe<Scalars["String"]>; o_effect?: Maybe<Scalars["_text"]>; o_react?: Maybe<Scalars["_text"]>; o_want?: Maybe<Scalars["_text"]>; prefix?: Maybe<Scalars["_text"]>; x_attr?: Maybe<Scalars["_text"]>; x_effect?: Maybe<Scalars["_text"]>; x_intent?: Maybe<Scalars["_text"]>; x_need?: Maybe<Scalars["_text"]>; x_react?: Maybe<Scalars["_text"]>; x_want?: Maybe<Scalars["_text"]> }

columns and relationships of "atomic.data"

Type declaration

Atomic_Data_Aggregate

Atomic_Data_Aggregate: { __typename?: "atomic_data_aggregate"; aggregate?: Maybe<Atomic_Data_Aggregate_Fields>; nodes: Atomic_Data[] }

aggregated selection of "atomic.data"

Type declaration

Atomic_Data_Aggregate_Fields

Atomic_Data_Aggregate_Fields: { __typename?: "atomic_data_aggregate_fields"; count: Scalars["Int"]; max?: Maybe<Atomic_Data_Max_Fields>; min?: Maybe<Atomic_Data_Min_Fields> }

aggregate fields of "atomic.data"

Type declaration

Atomic_Data_Aggregate_FieldsCountArgs

Atomic_Data_Aggregate_FieldsCountArgs: { columns?: Maybe<Atomic_Data_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "atomic.data"

Type declaration

Atomic_Data_Bool_Exp

Boolean expression to filter rows from the table "atomic.data". All fields are combined with a logical 'AND'.

Type declaration

Atomic_Data_Insert_Input

Atomic_Data_Insert_Input: { event?: Maybe<Scalars["String"]>; o_effect?: Maybe<Scalars["_text"]>; o_react?: Maybe<Scalars["_text"]>; o_want?: Maybe<Scalars["_text"]>; prefix?: Maybe<Scalars["_text"]>; x_attr?: Maybe<Scalars["_text"]>; x_effect?: Maybe<Scalars["_text"]>; x_intent?: Maybe<Scalars["_text"]>; x_need?: Maybe<Scalars["_text"]>; x_react?: Maybe<Scalars["_text"]>; x_want?: Maybe<Scalars["_text"]> }

input type for inserting data into table "atomic.data"

Type declaration

Atomic_Data_Max_Fields

Atomic_Data_Max_Fields: { __typename?: "atomic_data_max_fields"; event?: Maybe<Scalars["String"]> }

aggregate max on columns

Type declaration

  • Optional __typename?: "atomic_data_max_fields"
  • Optional event?: Maybe<Scalars["String"]>

Atomic_Data_Min_Fields

Atomic_Data_Min_Fields: { __typename?: "atomic_data_min_fields"; event?: Maybe<Scalars["String"]> }

aggregate min on columns

Type declaration

  • Optional __typename?: "atomic_data_min_fields"
  • Optional event?: Maybe<Scalars["String"]>

Atomic_Data_Mutation_Response

Atomic_Data_Mutation_Response: { __typename?: "atomic_data_mutation_response"; affected_rows: Scalars["Int"]; returning: Atomic_Data[] }

response of any mutation on the table "atomic.data"

Type declaration

  • Optional __typename?: "atomic_data_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Atomic_Data[]

    data from the rows affected by the mutation

Atomic_Data_Order_By

Atomic_Data_Order_By: { event?: Maybe<Order_By>; o_effect?: Maybe<Order_By>; o_react?: Maybe<Order_By>; o_want?: Maybe<Order_By>; prefix?: Maybe<Order_By>; x_attr?: Maybe<Order_By>; x_effect?: Maybe<Order_By>; x_intent?: Maybe<Order_By>; x_need?: Maybe<Order_By>; x_react?: Maybe<Order_By>; x_want?: Maybe<Order_By> }

Ordering options when selecting data from "atomic.data".

Type declaration

Atomic_Data_Set_Input

Atomic_Data_Set_Input: { event?: Maybe<Scalars["String"]>; o_effect?: Maybe<Scalars["_text"]>; o_react?: Maybe<Scalars["_text"]>; o_want?: Maybe<Scalars["_text"]>; prefix?: Maybe<Scalars["_text"]>; x_attr?: Maybe<Scalars["_text"]>; x_effect?: Maybe<Scalars["_text"]>; x_intent?: Maybe<Scalars["_text"]>; x_need?: Maybe<Scalars["_text"]>; x_react?: Maybe<Scalars["_text"]>; x_want?: Maybe<Scalars["_text"]> }

input type for updating data in table "atomic.data"

Type declaration

Audit_Logged_Actions

Audit_Logged_Actions: { __typename?: "audit_logged_actions"; action: Scalars["String"]; action_tstamp_clk: Scalars["timestamptz"]; action_tstamp_stm: Scalars["timestamptz"]; action_tstamp_tx: Scalars["timestamptz"]; application_name?: Maybe<Scalars["String"]>; changed_fields?: Maybe<Scalars["jsonb"]>; client_addr?: Maybe<Scalars["inet"]>; client_port?: Maybe<Scalars["Int"]>; client_query?: Maybe<Scalars["String"]>; event_id: Scalars["bigint"]; hasura_user?: Maybe<Scalars["jsonb"]>; relid: Scalars["oid"]; row_data?: Maybe<Scalars["jsonb"]>; schema_name: Scalars["String"]; session_user_name?: Maybe<Scalars["String"]>; statement_only: Scalars["Boolean"]; table_name: Scalars["String"]; transaction_id?: Maybe<Scalars["bigint"]> }

columns and relationships of "audit.logged_actions"

Type declaration

Audit_Logged_ActionsChanged_FieldsArgs

Audit_Logged_ActionsChanged_FieldsArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "audit.logged_actions"

Type declaration

Audit_Logged_ActionsHasura_UserArgs

Audit_Logged_ActionsHasura_UserArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "audit.logged_actions"

Type declaration

Audit_Logged_ActionsRow_DataArgs

Audit_Logged_ActionsRow_DataArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "audit.logged_actions"

Type declaration

Audit_Logged_Actions_Aggregate

Audit_Logged_Actions_Aggregate: { __typename?: "audit_logged_actions_aggregate"; aggregate?: Maybe<Audit_Logged_Actions_Aggregate_Fields>; nodes: Audit_Logged_Actions[] }

aggregated selection of "audit.logged_actions"

Type declaration

Audit_Logged_Actions_Aggregate_Fields

aggregate fields of "audit.logged_actions"

Type declaration

Audit_Logged_Actions_Aggregate_FieldsCountArgs

Audit_Logged_Actions_Aggregate_FieldsCountArgs: { columns?: Maybe<Audit_Logged_Actions_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "audit.logged_actions"

Type declaration

Audit_Logged_Actions_Append_Input

Audit_Logged_Actions_Append_Input: { changed_fields?: Maybe<Scalars["jsonb"]>; hasura_user?: Maybe<Scalars["jsonb"]>; row_data?: Maybe<Scalars["jsonb"]> }

append existing jsonb value of filtered columns with new jsonb value

Type declaration

Audit_Logged_Actions_Avg_Fields

Audit_Logged_Actions_Avg_Fields: { __typename?: "audit_logged_actions_avg_fields"; client_port?: Maybe<Scalars["Float"]>; event_id?: Maybe<Scalars["Float"]>; transaction_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "audit_logged_actions_avg_fields"
  • Optional client_port?: Maybe<Scalars["Float"]>
  • Optional event_id?: Maybe<Scalars["Float"]>
  • Optional transaction_id?: Maybe<Scalars["Float"]>

Audit_Logged_Actions_Bool_Exp

Audit_Logged_Actions_Bool_Exp: { _and?: Maybe<Audit_Logged_Actions_Bool_Exp[]>; _not?: Maybe<Audit_Logged_Actions_Bool_Exp>; _or?: Maybe<Audit_Logged_Actions_Bool_Exp[]>; action?: Maybe<String_Comparison_Exp>; action_tstamp_clk?: Maybe<Timestamptz_Comparison_Exp>; action_tstamp_stm?: Maybe<Timestamptz_Comparison_Exp>; action_tstamp_tx?: Maybe<Timestamptz_Comparison_Exp>; application_name?: Maybe<String_Comparison_Exp>; changed_fields?: Maybe<Jsonb_Comparison_Exp>; client_addr?: Maybe<Inet_Comparison_Exp>; client_port?: Maybe<Int_Comparison_Exp>; client_query?: Maybe<String_Comparison_Exp>; event_id?: Maybe<Bigint_Comparison_Exp>; hasura_user?: Maybe<Jsonb_Comparison_Exp>; relid?: Maybe<Oid_Comparison_Exp>; row_data?: Maybe<Jsonb_Comparison_Exp>; schema_name?: Maybe<String_Comparison_Exp>; session_user_name?: Maybe<String_Comparison_Exp>; statement_only?: Maybe<Boolean_Comparison_Exp>; table_name?: Maybe<String_Comparison_Exp>; transaction_id?: Maybe<Bigint_Comparison_Exp> }

Boolean expression to filter rows from the table "audit.logged_actions". All fields are combined with a logical 'AND'.

Type declaration

Audit_Logged_Actions_Delete_At_Path_Input

Audit_Logged_Actions_Delete_At_Path_Input: { changed_fields?: Maybe<Scalars["String"][]>; hasura_user?: Maybe<Scalars["String"][]>; row_data?: Maybe<Scalars["String"][]> }

delete the field or element with specified path (for JSON arrays, negative integers count from the end)

Type declaration

Audit_Logged_Actions_Delete_Elem_Input

Audit_Logged_Actions_Delete_Elem_Input: { changed_fields?: Maybe<Scalars["Int"]>; hasura_user?: Maybe<Scalars["Int"]>; row_data?: Maybe<Scalars["Int"]> }

delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array

Type declaration

Audit_Logged_Actions_Delete_Key_Input

Audit_Logged_Actions_Delete_Key_Input: { changed_fields?: Maybe<Scalars["String"]>; hasura_user?: Maybe<Scalars["String"]>; row_data?: Maybe<Scalars["String"]> }

delete key/value pair or string element. key/value pairs are matched based on their key value

Type declaration

Audit_Logged_Actions_Inc_Input

Audit_Logged_Actions_Inc_Input: { client_port?: Maybe<Scalars["Int"]>; event_id?: Maybe<Scalars["bigint"]>; transaction_id?: Maybe<Scalars["bigint"]> }

input type for incrementing numeric columns in table "audit.logged_actions"

Type declaration

Audit_Logged_Actions_Insert_Input

Audit_Logged_Actions_Insert_Input: { action?: Maybe<Scalars["String"]>; action_tstamp_clk?: Maybe<Scalars["timestamptz"]>; action_tstamp_stm?: Maybe<Scalars["timestamptz"]>; action_tstamp_tx?: Maybe<Scalars["timestamptz"]>; application_name?: Maybe<Scalars["String"]>; changed_fields?: Maybe<Scalars["jsonb"]>; client_addr?: Maybe<Scalars["inet"]>; client_port?: Maybe<Scalars["Int"]>; client_query?: Maybe<Scalars["String"]>; event_id?: Maybe<Scalars["bigint"]>; hasura_user?: Maybe<Scalars["jsonb"]>; relid?: Maybe<Scalars["oid"]>; row_data?: Maybe<Scalars["jsonb"]>; schema_name?: Maybe<Scalars["String"]>; session_user_name?: Maybe<Scalars["String"]>; statement_only?: Maybe<Scalars["Boolean"]>; table_name?: Maybe<Scalars["String"]>; transaction_id?: Maybe<Scalars["bigint"]> }

input type for inserting data into table "audit.logged_actions"

Type declaration

Audit_Logged_Actions_Max_Fields

Audit_Logged_Actions_Max_Fields: { __typename?: "audit_logged_actions_max_fields"; action?: Maybe<Scalars["String"]>; action_tstamp_clk?: Maybe<Scalars["timestamptz"]>; action_tstamp_stm?: Maybe<Scalars["timestamptz"]>; action_tstamp_tx?: Maybe<Scalars["timestamptz"]>; application_name?: Maybe<Scalars["String"]>; client_port?: Maybe<Scalars["Int"]>; client_query?: Maybe<Scalars["String"]>; event_id?: Maybe<Scalars["bigint"]>; schema_name?: Maybe<Scalars["String"]>; session_user_name?: Maybe<Scalars["String"]>; table_name?: Maybe<Scalars["String"]>; transaction_id?: Maybe<Scalars["bigint"]> }

aggregate max on columns

Type declaration

Audit_Logged_Actions_Min_Fields

Audit_Logged_Actions_Min_Fields: { __typename?: "audit_logged_actions_min_fields"; action?: Maybe<Scalars["String"]>; action_tstamp_clk?: Maybe<Scalars["timestamptz"]>; action_tstamp_stm?: Maybe<Scalars["timestamptz"]>; action_tstamp_tx?: Maybe<Scalars["timestamptz"]>; application_name?: Maybe<Scalars["String"]>; client_port?: Maybe<Scalars["Int"]>; client_query?: Maybe<Scalars["String"]>; event_id?: Maybe<Scalars["bigint"]>; schema_name?: Maybe<Scalars["String"]>; session_user_name?: Maybe<Scalars["String"]>; table_name?: Maybe<Scalars["String"]>; transaction_id?: Maybe<Scalars["bigint"]> }

aggregate min on columns

Type declaration

Audit_Logged_Actions_Mutation_Response

Audit_Logged_Actions_Mutation_Response: { __typename?: "audit_logged_actions_mutation_response"; affected_rows: Scalars["Int"]; returning: Audit_Logged_Actions[] }

response of any mutation on the table "audit.logged_actions"

Type declaration

  • Optional __typename?: "audit_logged_actions_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Audit_Logged_Actions[]

    data from the rows affected by the mutation

Audit_Logged_Actions_On_Conflict

Audit_Logged_Actions_On_Conflict: { constraint: Audit_Logged_Actions_Constraint; update_columns: Audit_Logged_Actions_Update_Column[]; where?: Maybe<Audit_Logged_Actions_Bool_Exp> }

on conflict condition type for table "audit.logged_actions"

Type declaration

Audit_Logged_Actions_Order_By

Audit_Logged_Actions_Order_By: { action?: Maybe<Order_By>; action_tstamp_clk?: Maybe<Order_By>; action_tstamp_stm?: Maybe<Order_By>; action_tstamp_tx?: Maybe<Order_By>; application_name?: Maybe<Order_By>; changed_fields?: Maybe<Order_By>; client_addr?: Maybe<Order_By>; client_port?: Maybe<Order_By>; client_query?: Maybe<Order_By>; event_id?: Maybe<Order_By>; hasura_user?: Maybe<Order_By>; relid?: Maybe<Order_By>; row_data?: Maybe<Order_By>; schema_name?: Maybe<Order_By>; session_user_name?: Maybe<Order_By>; statement_only?: Maybe<Order_By>; table_name?: Maybe<Order_By>; transaction_id?: Maybe<Order_By> }

Ordering options when selecting data from "audit.logged_actions".

Type declaration

Audit_Logged_Actions_Pk_Columns_Input

Audit_Logged_Actions_Pk_Columns_Input: { action_tstamp_stm: Scalars["timestamptz"]; event_id: Scalars["bigint"] }

primary key columns input for table: audit_logged_actions

Type declaration

  • action_tstamp_stm: Scalars["timestamptz"]
  • event_id: Scalars["bigint"]

Audit_Logged_Actions_Prepend_Input

Audit_Logged_Actions_Prepend_Input: { changed_fields?: Maybe<Scalars["jsonb"]>; hasura_user?: Maybe<Scalars["jsonb"]>; row_data?: Maybe<Scalars["jsonb"]> }

prepend existing jsonb value of filtered columns with new jsonb value

Type declaration

Audit_Logged_Actions_Set_Input

Audit_Logged_Actions_Set_Input: { action?: Maybe<Scalars["String"]>; action_tstamp_clk?: Maybe<Scalars["timestamptz"]>; action_tstamp_stm?: Maybe<Scalars["timestamptz"]>; action_tstamp_tx?: Maybe<Scalars["timestamptz"]>; application_name?: Maybe<Scalars["String"]>; changed_fields?: Maybe<Scalars["jsonb"]>; client_addr?: Maybe<Scalars["inet"]>; client_port?: Maybe<Scalars["Int"]>; client_query?: Maybe<Scalars["String"]>; event_id?: Maybe<Scalars["bigint"]>; hasura_user?: Maybe<Scalars["jsonb"]>; relid?: Maybe<Scalars["oid"]>; row_data?: Maybe<Scalars["jsonb"]>; schema_name?: Maybe<Scalars["String"]>; session_user_name?: Maybe<Scalars["String"]>; statement_only?: Maybe<Scalars["Boolean"]>; table_name?: Maybe<Scalars["String"]>; transaction_id?: Maybe<Scalars["bigint"]> }

input type for updating data in table "audit.logged_actions"

Type declaration

Audit_Logged_Actions_Stddev_Fields

Audit_Logged_Actions_Stddev_Fields: { __typename?: "audit_logged_actions_stddev_fields"; client_port?: Maybe<Scalars["Float"]>; event_id?: Maybe<Scalars["Float"]>; transaction_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "audit_logged_actions_stddev_fields"
  • Optional client_port?: Maybe<Scalars["Float"]>
  • Optional event_id?: Maybe<Scalars["Float"]>
  • Optional transaction_id?: Maybe<Scalars["Float"]>

Audit_Logged_Actions_Stddev_Pop_Fields

Audit_Logged_Actions_Stddev_Pop_Fields: { __typename?: "audit_logged_actions_stddev_pop_fields"; client_port?: Maybe<Scalars["Float"]>; event_id?: Maybe<Scalars["Float"]>; transaction_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "audit_logged_actions_stddev_pop_fields"
  • Optional client_port?: Maybe<Scalars["Float"]>
  • Optional event_id?: Maybe<Scalars["Float"]>
  • Optional transaction_id?: Maybe<Scalars["Float"]>

Audit_Logged_Actions_Stddev_Samp_Fields

Audit_Logged_Actions_Stddev_Samp_Fields: { __typename?: "audit_logged_actions_stddev_samp_fields"; client_port?: Maybe<Scalars["Float"]>; event_id?: Maybe<Scalars["Float"]>; transaction_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "audit_logged_actions_stddev_samp_fields"
  • Optional client_port?: Maybe<Scalars["Float"]>
  • Optional event_id?: Maybe<Scalars["Float"]>
  • Optional transaction_id?: Maybe<Scalars["Float"]>

Audit_Logged_Actions_Sum_Fields

Audit_Logged_Actions_Sum_Fields: { __typename?: "audit_logged_actions_sum_fields"; client_port?: Maybe<Scalars["Int"]>; event_id?: Maybe<Scalars["bigint"]>; transaction_id?: Maybe<Scalars["bigint"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "audit_logged_actions_sum_fields"
  • Optional client_port?: Maybe<Scalars["Int"]>
  • Optional event_id?: Maybe<Scalars["bigint"]>
  • Optional transaction_id?: Maybe<Scalars["bigint"]>

Audit_Logged_Actions_Var_Pop_Fields

Audit_Logged_Actions_Var_Pop_Fields: { __typename?: "audit_logged_actions_var_pop_fields"; client_port?: Maybe<Scalars["Float"]>; event_id?: Maybe<Scalars["Float"]>; transaction_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "audit_logged_actions_var_pop_fields"
  • Optional client_port?: Maybe<Scalars["Float"]>
  • Optional event_id?: Maybe<Scalars["Float"]>
  • Optional transaction_id?: Maybe<Scalars["Float"]>

Audit_Logged_Actions_Var_Samp_Fields

Audit_Logged_Actions_Var_Samp_Fields: { __typename?: "audit_logged_actions_var_samp_fields"; client_port?: Maybe<Scalars["Float"]>; event_id?: Maybe<Scalars["Float"]>; transaction_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "audit_logged_actions_var_samp_fields"
  • Optional client_port?: Maybe<Scalars["Float"]>
  • Optional event_id?: Maybe<Scalars["Float"]>
  • Optional transaction_id?: Maybe<Scalars["Float"]>

Audit_Logged_Actions_Variance_Fields

Audit_Logged_Actions_Variance_Fields: { __typename?: "audit_logged_actions_variance_fields"; client_port?: Maybe<Scalars["Float"]>; event_id?: Maybe<Scalars["Float"]>; transaction_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "audit_logged_actions_variance_fields"
  • Optional client_port?: Maybe<Scalars["Float"]>
  • Optional event_id?: Maybe<Scalars["Float"]>
  • Optional transaction_id?: Maybe<Scalars["Float"]>

Bigint_Comparison_Exp

Bigint_Comparison_Exp: { _eq?: Maybe<Scalars["bigint"]>; _gt?: Maybe<Scalars["bigint"]>; _gte?: Maybe<Scalars["bigint"]>; _in?: Maybe<Scalars["bigint"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["bigint"]>; _lte?: Maybe<Scalars["bigint"]>; _neq?: Maybe<Scalars["bigint"]>; _nin?: Maybe<Scalars["bigint"][]> }

Boolean expression to compare columns of type "bigint". All fields are combined with logical 'AND'.

Type declaration

Boolean_Comparison_Exp

Boolean_Comparison_Exp: { _eq?: Maybe<Scalars["Boolean"]>; _gt?: Maybe<Scalars["Boolean"]>; _gte?: Maybe<Scalars["Boolean"]>; _in?: Maybe<Scalars["Boolean"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["Boolean"]>; _lte?: Maybe<Scalars["Boolean"]>; _neq?: Maybe<Scalars["Boolean"]>; _nin?: Maybe<Scalars["Boolean"][]> }

Boolean expression to compare columns of type "Boolean". All fields are combined with logical 'AND'.

Type declaration

Cat

Cat: { __typename?: "Cat"; end?: Maybe<Scalars["Int"]>; label?: Maybe<Scalars["String"]>; score?: Maybe<Scalars["Float"]>; start?: Maybe<Scalars["Int"]> }

Category applied to whole document (label, score), or to spans (start, end, label, score).

Type declaration

  • Optional __typename?: "Cat"
  • Optional end?: Maybe<Scalars["Int"]>

    Span end position

  • Optional label?: Maybe<Scalars["String"]>

    Document label

  • Optional score?: Maybe<Scalars["Float"]>

    Document score

  • Optional start?: Maybe<Scalars["Int"]>

    Span start position

ChitchatQuery

ChitchatQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "ChitchatResponse" } & { reply: ChitchatResponse["result"] }> }

ChitchatQueryVariables

ChitchatQueryVariables: Exact<{ history: Turn[] | Turn; input: Scalars["String"] }>

ChitchatResponse

ChitchatResponse: { __typename?: "ChitchatResponse"; result?: Maybe<Scalars["String"]> }

Chitchat results

Type declaration

  • Optional __typename?: "ChitchatResponse"
  • Optional result?: Maybe<Scalars["String"]>

ClassificationResult

ClassificationResult: { __typename?: "ClassificationResult"; result?: Maybe<Maybe<TopicScore>[]> }

Topic classification results

Type declaration

ClassifyTopicQuery

ClassifyTopicQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "ClassificationResult" } & { topics?: Maybe<Maybe<{ __typename?: "TopicScore" } & Pick<TopicScore, "topic" | "score">>[]> }> }

ClassifyTopicQueryVariables

ClassifyTopicQueryVariables: Exact<{ input: Scalars["String"]; topics: Scalars["String"][] | Scalars["String"] }>

CommonsenseReasoningQuery

CommonsenseReasoningQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "RelationResult" } & { predictions: RelationResult["result"] }> }

CommonsenseReasoningQueryVariables

CommonsenseReasoningQueryVariables: Exact<{ category: Category; input: Scalars["String"] }>

ComposeResult

ComposeResult: { __typename?: "ComposeResult"; result?: Maybe<Scalars["JSON"]> }

Output result

Type declaration

  • Optional __typename?: "ComposeResult"
  • Optional result?: Maybe<Scalars["JSON"]>

    Resulting JSON

Conceptnet_Data

Conceptnet_Data: { __typename?: "conceptnet_data"; end: Scalars["String"]; relation: Scalars["String"]; start: Scalars["String"]; uri: Scalars["String"]; weight: Scalars["numeric"] }

columns and relationships of "conceptnet.data"

Type declaration

Conceptnet_Data_Aggregate

Conceptnet_Data_Aggregate: { __typename?: "conceptnet_data_aggregate"; aggregate?: Maybe<Conceptnet_Data_Aggregate_Fields>; nodes: Conceptnet_Data[] }

aggregated selection of "conceptnet.data"

Type declaration

Conceptnet_Data_Aggregate_Fields

Conceptnet_Data_Aggregate_Fields: { __typename?: "conceptnet_data_aggregate_fields"; avg?: Maybe<Conceptnet_Data_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<Conceptnet_Data_Max_Fields>; min?: Maybe<Conceptnet_Data_Min_Fields>; stddev?: Maybe<Conceptnet_Data_Stddev_Fields>; stddev_pop?: Maybe<Conceptnet_Data_Stddev_Pop_Fields>; stddev_samp?: Maybe<Conceptnet_Data_Stddev_Samp_Fields>; sum?: Maybe<Conceptnet_Data_Sum_Fields>; var_pop?: Maybe<Conceptnet_Data_Var_Pop_Fields>; var_samp?: Maybe<Conceptnet_Data_Var_Samp_Fields>; variance?: Maybe<Conceptnet_Data_Variance_Fields> }

aggregate fields of "conceptnet.data"

Type declaration

Conceptnet_Data_Aggregate_FieldsCountArgs

Conceptnet_Data_Aggregate_FieldsCountArgs: { columns?: Maybe<Conceptnet_Data_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "conceptnet.data"

Type declaration

Conceptnet_Data_Avg_Fields

Conceptnet_Data_Avg_Fields: { __typename?: "conceptnet_data_avg_fields"; weight?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "conceptnet_data_avg_fields"
  • Optional weight?: Maybe<Scalars["Float"]>

Conceptnet_Data_Bool_Exp

Boolean expression to filter rows from the table "conceptnet.data". All fields are combined with a logical 'AND'.

Type declaration

Conceptnet_Data_Inc_Input

Conceptnet_Data_Inc_Input: { weight?: Maybe<Scalars["numeric"]> }

input type for incrementing numeric columns in table "conceptnet.data"

Type declaration

Conceptnet_Data_Insert_Input

Conceptnet_Data_Insert_Input: { end?: Maybe<Scalars["String"]>; relation?: Maybe<Scalars["String"]>; start?: Maybe<Scalars["String"]>; uri?: Maybe<Scalars["String"]>; weight?: Maybe<Scalars["numeric"]> }

input type for inserting data into table "conceptnet.data"

Type declaration

Conceptnet_Data_Max_Fields

Conceptnet_Data_Max_Fields: { __typename?: "conceptnet_data_max_fields"; end?: Maybe<Scalars["String"]>; relation?: Maybe<Scalars["String"]>; start?: Maybe<Scalars["String"]>; uri?: Maybe<Scalars["String"]>; weight?: Maybe<Scalars["numeric"]> }

aggregate max on columns

Type declaration

Conceptnet_Data_Min_Fields

Conceptnet_Data_Min_Fields: { __typename?: "conceptnet_data_min_fields"; end?: Maybe<Scalars["String"]>; relation?: Maybe<Scalars["String"]>; start?: Maybe<Scalars["String"]>; uri?: Maybe<Scalars["String"]>; weight?: Maybe<Scalars["numeric"]> }

aggregate min on columns

Type declaration

Conceptnet_Data_Mutation_Response

Conceptnet_Data_Mutation_Response: { __typename?: "conceptnet_data_mutation_response"; affected_rows: Scalars["Int"]; returning: Conceptnet_Data[] }

response of any mutation on the table "conceptnet.data"

Type declaration

  • Optional __typename?: "conceptnet_data_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Conceptnet_Data[]

    data from the rows affected by the mutation

Conceptnet_Data_On_Conflict

Conceptnet_Data_On_Conflict: { constraint: Conceptnet_Data_Constraint; update_columns: Conceptnet_Data_Update_Column[]; where?: Maybe<Conceptnet_Data_Bool_Exp> }

on conflict condition type for table "conceptnet.data"

Type declaration

Conceptnet_Data_Order_By

Conceptnet_Data_Order_By: { end?: Maybe<Order_By>; relation?: Maybe<Order_By>; start?: Maybe<Order_By>; uri?: Maybe<Order_By>; weight?: Maybe<Order_By> }

Ordering options when selecting data from "conceptnet.data".

Type declaration

Conceptnet_Data_Set_Input

Conceptnet_Data_Set_Input: { end?: Maybe<Scalars["String"]>; relation?: Maybe<Scalars["String"]>; start?: Maybe<Scalars["String"]>; uri?: Maybe<Scalars["String"]>; weight?: Maybe<Scalars["numeric"]> }

input type for updating data in table "conceptnet.data"

Type declaration

Conceptnet_Data_Stddev_Fields

Conceptnet_Data_Stddev_Fields: { __typename?: "conceptnet_data_stddev_fields"; weight?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "conceptnet_data_stddev_fields"
  • Optional weight?: Maybe<Scalars["Float"]>

Conceptnet_Data_Stddev_Pop_Fields

Conceptnet_Data_Stddev_Pop_Fields: { __typename?: "conceptnet_data_stddev_pop_fields"; weight?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "conceptnet_data_stddev_pop_fields"
  • Optional weight?: Maybe<Scalars["Float"]>

Conceptnet_Data_Stddev_Samp_Fields

Conceptnet_Data_Stddev_Samp_Fields: { __typename?: "conceptnet_data_stddev_samp_fields"; weight?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "conceptnet_data_stddev_samp_fields"
  • Optional weight?: Maybe<Scalars["Float"]>

Conceptnet_Data_Sum_Fields

Conceptnet_Data_Sum_Fields: { __typename?: "conceptnet_data_sum_fields"; weight?: Maybe<Scalars["numeric"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "conceptnet_data_sum_fields"
  • Optional weight?: Maybe<Scalars["numeric"]>

Conceptnet_Data_Var_Pop_Fields

Conceptnet_Data_Var_Pop_Fields: { __typename?: "conceptnet_data_var_pop_fields"; weight?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "conceptnet_data_var_pop_fields"
  • Optional weight?: Maybe<Scalars["Float"]>

Conceptnet_Data_Var_Samp_Fields

Conceptnet_Data_Var_Samp_Fields: { __typename?: "conceptnet_data_var_samp_fields"; weight?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "conceptnet_data_var_samp_fields"
  • Optional weight?: Maybe<Scalars["Float"]>

Conceptnet_Data_Variance_Fields

Conceptnet_Data_Variance_Fields: { __typename?: "conceptnet_data_variance_fields"; weight?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "conceptnet_data_variance_fields"
  • Optional weight?: Maybe<Scalars["Float"]>

Conceptnet_Search_Relations_Args

Conceptnet_Search_Relations_Args: { limit_to?: Maybe<Scalars["numeric"]>; search?: Maybe<Scalars["String"]> }

Type declaration

Container

Container: { has_vector?: Maybe<Scalars["Boolean"]>; text?: Maybe<Scalars["String"]>; text_with_ws?: Maybe<Scalars["String"]>; vector?: Maybe<Maybe<Scalars["Float"]>[]>; vector_norm?: Maybe<Scalars["Float"]> }

Type declaration

  • Optional has_vector?: Maybe<Scalars["Boolean"]>

    A boolean value indicating whether a word vector is associated with the object.

  • Optional text?: Maybe<Scalars["String"]>

    Verbatim text content.

  • Optional text_with_ws?: Maybe<Scalars["String"]>

    Text content, with trailing space character if present.

  • Optional vector?: Maybe<Maybe<Scalars["Float"]>[]>

    A real-valued meaning representation.

  • Optional vector_norm?: Maybe<Scalars["Float"]>

    The L2 norm of the document’s vector representation.

ContextResult

ContextResult: { __typename?: "ContextResult"; result?: Maybe<Maybe<SlingDocument>[]> }

SLING document container

Type declaration

Conversations

Conversations: { __typename?: "conversations"; app: Apps; app_id: Scalars["Int"]; created_at: Scalars["timestamptz"]; destroyed_at?: Maybe<Scalars["timestamptz"]>; end_user: End_Users; end_user_conversations: End_User_Conversations[]; end_user_conversations_aggregate: End_User_Conversations_Aggregate; end_user_id: Scalars["Int"]; kv_store: Kv_Store[]; kv_store_aggregate: Kv_Store_Aggregate; metadata: Scalars["jsonb"]; object_id: Scalars["Int"]; scope_name?: Maybe<Scalars["String"]>; utterances: Utterances[]; utterances_aggregate: Utterances_Aggregate }

columns and relationships of "conversations"

Type declaration

ConversationsEnd_User_ConversationsArgs

ConversationsEnd_User_ConversationsArgs: { distinct_on?: Maybe<End_User_Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_User_Conversations_Order_By[]>; where?: Maybe<End_User_Conversations_Bool_Exp> }

columns and relationships of "conversations"

Type declaration

ConversationsEnd_User_Conversations_AggregateArgs

ConversationsEnd_User_Conversations_AggregateArgs: { distinct_on?: Maybe<End_User_Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_User_Conversations_Order_By[]>; where?: Maybe<End_User_Conversations_Bool_Exp> }

columns and relationships of "conversations"

Type declaration

ConversationsKv_StoreArgs

ConversationsKv_StoreArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

columns and relationships of "conversations"

Type declaration

ConversationsKv_Store_AggregateArgs

ConversationsKv_Store_AggregateArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

columns and relationships of "conversations"

Type declaration

ConversationsMetadataArgs

ConversationsMetadataArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "conversations"

Type declaration

ConversationsUtterancesArgs

ConversationsUtterancesArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

columns and relationships of "conversations"

Type declaration

ConversationsUtterances_AggregateArgs

ConversationsUtterances_AggregateArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

columns and relationships of "conversations"

Type declaration

Conversations_Aggregate

Conversations_Aggregate: { __typename?: "conversations_aggregate"; aggregate?: Maybe<Conversations_Aggregate_Fields>; nodes: Conversations[] }

aggregated selection of "conversations"

Type declaration

Conversations_Aggregate_Fields

Conversations_Aggregate_Fields: { __typename?: "conversations_aggregate_fields"; avg?: Maybe<Conversations_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<Conversations_Max_Fields>; min?: Maybe<Conversations_Min_Fields>; stddev?: Maybe<Conversations_Stddev_Fields>; stddev_pop?: Maybe<Conversations_Stddev_Pop_Fields>; stddev_samp?: Maybe<Conversations_Stddev_Samp_Fields>; sum?: Maybe<Conversations_Sum_Fields>; var_pop?: Maybe<Conversations_Var_Pop_Fields>; var_samp?: Maybe<Conversations_Var_Samp_Fields>; variance?: Maybe<Conversations_Variance_Fields> }

aggregate fields of "conversations"

Type declaration

Conversations_Aggregate_FieldsCountArgs

Conversations_Aggregate_FieldsCountArgs: { columns?: Maybe<Conversations_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "conversations"

Type declaration

Conversations_Aggregate_Order_By

order by aggregate values of table "conversations"

Type declaration

Conversations_Append_Input

Conversations_Append_Input: { metadata?: Maybe<Scalars["jsonb"]> }

append existing jsonb value of filtered columns with new jsonb value

Type declaration

Conversations_Arr_Rel_Insert_Input

Conversations_Arr_Rel_Insert_Input: { data: Conversations_Insert_Input[]; on_conflict?: Maybe<Conversations_On_Conflict> }

input type for inserting array relation for remote table "conversations"

Type declaration

Conversations_Avg_Fields

Conversations_Avg_Fields: { __typename?: "conversations_avg_fields"; app_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "conversations_avg_fields"
  • Optional app_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Conversations_Avg_Order_By

Conversations_Avg_Order_By: { app_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by avg() on columns of table "conversations"

Type declaration

Conversations_Bool_Exp

Conversations_Bool_Exp: { _and?: Maybe<Conversations_Bool_Exp[]>; _not?: Maybe<Conversations_Bool_Exp>; _or?: Maybe<Conversations_Bool_Exp[]>; app?: Maybe<Apps_Bool_Exp>; app_id?: Maybe<Int_Comparison_Exp>; created_at?: Maybe<Timestamptz_Comparison_Exp>; destroyed_at?: Maybe<Timestamptz_Comparison_Exp>; end_user?: Maybe<End_Users_Bool_Exp>; end_user_conversations?: Maybe<End_User_Conversations_Bool_Exp>; end_user_id?: Maybe<Int_Comparison_Exp>; kv_store?: Maybe<Kv_Store_Bool_Exp>; metadata?: Maybe<Jsonb_Comparison_Exp>; object_id?: Maybe<Int_Comparison_Exp>; scope_name?: Maybe<String_Comparison_Exp>; utterances?: Maybe<Utterances_Bool_Exp> }

Boolean expression to filter rows from the table "conversations". All fields are combined with a logical 'AND'.

Type declaration

Conversations_Delete_At_Path_Input

Conversations_Delete_At_Path_Input: { metadata?: Maybe<Scalars["String"][]> }

delete the field or element with specified path (for JSON arrays, negative integers count from the end)

Type declaration

Conversations_Delete_Elem_Input

Conversations_Delete_Elem_Input: { metadata?: Maybe<Scalars["Int"]> }

delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array

Type declaration

Conversations_Delete_Key_Input

Conversations_Delete_Key_Input: { metadata?: Maybe<Scalars["String"]> }

delete key/value pair or string element. key/value pairs are matched based on their key value

Type declaration

Conversations_Inc_Input

Conversations_Inc_Input: { app_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]> }

input type for incrementing numeric columns in table "conversations"

Type declaration

Conversations_Insert_Input

Conversations_Insert_Input: { app?: Maybe<Apps_Obj_Rel_Insert_Input>; app_id?: Maybe<Scalars["Int"]>; created_at?: Maybe<Scalars["timestamptz"]>; destroyed_at?: Maybe<Scalars["timestamptz"]>; end_user?: Maybe<End_Users_Obj_Rel_Insert_Input>; end_user_conversations?: Maybe<End_User_Conversations_Arr_Rel_Insert_Input>; end_user_id?: Maybe<Scalars["Int"]>; kv_store?: Maybe<Kv_Store_Arr_Rel_Insert_Input>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]>; utterances?: Maybe<Utterances_Arr_Rel_Insert_Input> }

input type for inserting data into table "conversations"

Type declaration

Conversations_Max_Fields

Conversations_Max_Fields: { __typename?: "conversations_max_fields"; app_id?: Maybe<Scalars["Int"]>; created_at?: Maybe<Scalars["timestamptz"]>; destroyed_at?: Maybe<Scalars["timestamptz"]>; end_user_id?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]> }

aggregate max on columns

Type declaration

Conversations_Max_Order_By

Conversations_Max_Order_By: { app_id?: Maybe<Order_By>; created_at?: Maybe<Order_By>; destroyed_at?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_name?: Maybe<Order_By> }

order by max() on columns of table "conversations"

Type declaration

Conversations_Min_Fields

Conversations_Min_Fields: { __typename?: "conversations_min_fields"; app_id?: Maybe<Scalars["Int"]>; created_at?: Maybe<Scalars["timestamptz"]>; destroyed_at?: Maybe<Scalars["timestamptz"]>; end_user_id?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]> }

aggregate min on columns

Type declaration

Conversations_Min_Order_By

Conversations_Min_Order_By: { app_id?: Maybe<Order_By>; created_at?: Maybe<Order_By>; destroyed_at?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_name?: Maybe<Order_By> }

order by min() on columns of table "conversations"

Type declaration

Conversations_Mutation_Response

Conversations_Mutation_Response: { __typename?: "conversations_mutation_response"; affected_rows: Scalars["Int"]; returning: Conversations[] }

response of any mutation on the table "conversations"

Type declaration

  • Optional __typename?: "conversations_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Conversations[]

    data from the rows affected by the mutation

Conversations_Obj_Rel_Insert_Input

Conversations_Obj_Rel_Insert_Input: { data: Conversations_Insert_Input; on_conflict?: Maybe<Conversations_On_Conflict> }

input type for inserting object relation for remote table "conversations"

Type declaration

Conversations_On_Conflict

Conversations_On_Conflict: { constraint: Conversations_Constraint; update_columns: Conversations_Update_Column[]; where?: Maybe<Conversations_Bool_Exp> }

on conflict condition type for table "conversations"

Type declaration

Conversations_Order_By

Conversations_Order_By: { app?: Maybe<Apps_Order_By>; app_id?: Maybe<Order_By>; created_at?: Maybe<Order_By>; destroyed_at?: Maybe<Order_By>; end_user?: Maybe<End_Users_Order_By>; end_user_conversations_aggregate?: Maybe<End_User_Conversations_Aggregate_Order_By>; end_user_id?: Maybe<Order_By>; kv_store_aggregate?: Maybe<Kv_Store_Aggregate_Order_By>; metadata?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_name?: Maybe<Order_By>; utterances_aggregate?: Maybe<Utterances_Aggregate_Order_By> }

Ordering options when selecting data from "conversations".

Type declaration

Conversations_Prepend_Input

Conversations_Prepend_Input: { metadata?: Maybe<Scalars["jsonb"]> }

prepend existing jsonb value of filtered columns with new jsonb value

Type declaration

Conversations_Set_Input

Conversations_Set_Input: { app_id?: Maybe<Scalars["Int"]>; created_at?: Maybe<Scalars["timestamptz"]>; destroyed_at?: Maybe<Scalars["timestamptz"]>; end_user_id?: Maybe<Scalars["Int"]>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]> }

input type for updating data in table "conversations"

Type declaration

Conversations_Stddev_Fields

Conversations_Stddev_Fields: { __typename?: "conversations_stddev_fields"; app_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "conversations_stddev_fields"
  • Optional app_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Conversations_Stddev_Order_By

Conversations_Stddev_Order_By: { app_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by stddev() on columns of table "conversations"

Type declaration

Conversations_Stddev_Pop_Fields

Conversations_Stddev_Pop_Fields: { __typename?: "conversations_stddev_pop_fields"; app_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "conversations_stddev_pop_fields"
  • Optional app_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Conversations_Stddev_Pop_Order_By

Conversations_Stddev_Pop_Order_By: { app_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by stddev_pop() on columns of table "conversations"

Type declaration

Conversations_Stddev_Samp_Fields

Conversations_Stddev_Samp_Fields: { __typename?: "conversations_stddev_samp_fields"; app_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "conversations_stddev_samp_fields"
  • Optional app_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Conversations_Stddev_Samp_Order_By

Conversations_Stddev_Samp_Order_By: { app_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by stddev_samp() on columns of table "conversations"

Type declaration

Conversations_Sum_Fields

Conversations_Sum_Fields: { __typename?: "conversations_sum_fields"; app_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

Conversations_Sum_Order_By

Conversations_Sum_Order_By: { app_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by sum() on columns of table "conversations"

Type declaration

Conversations_Var_Pop_Fields

Conversations_Var_Pop_Fields: { __typename?: "conversations_var_pop_fields"; app_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "conversations_var_pop_fields"
  • Optional app_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Conversations_Var_Pop_Order_By

Conversations_Var_Pop_Order_By: { app_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by var_pop() on columns of table "conversations"

Type declaration

Conversations_Var_Samp_Fields

Conversations_Var_Samp_Fields: { __typename?: "conversations_var_samp_fields"; app_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "conversations_var_samp_fields"
  • Optional app_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Conversations_Var_Samp_Order_By

Conversations_Var_Samp_Order_By: { app_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by var_samp() on columns of table "conversations"

Type declaration

Conversations_Variance_Fields

Conversations_Variance_Fields: { __typename?: "conversations_variance_fields"; app_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "conversations_variance_fields"
  • Optional app_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>

Conversations_Variance_Order_By

Conversations_Variance_Order_By: { app_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

order by variance() on columns of table "conversations"

Type declaration

CorefCluster

CorefCluster: { __typename?: "CorefCluster"; i?: Maybe<Scalars["Int"]> }

Type declaration

  • Optional __typename?: "CorefCluster"
  • Optional i?: Maybe<Scalars["Int"]>

    Index of the cluster in the Doc

CorefResult

CorefResult: { __typename?: "CorefResult"; coreferences?: Maybe<Maybe<CorefResultScores>[]>; has_coreference?: Maybe<Scalars["Boolean"]>; result?: Maybe<Scalars["String"]> }

Coreference resolution data

Type declaration

  • Optional __typename?: "CorefResult"
  • Optional coreferences?: Maybe<Maybe<CorefResultScores>[]>

    Scores of the coreference resolution between mentions.

  • Optional has_coreference?: Maybe<Scalars["Boolean"]>

    Has any coreference has been resolved in the Doc

  • Optional result?: Maybe<Scalars["String"]>

    Unicode representation of the doc where each corefering mention is replaced by the main mention in the associated cluster.

CorefResultScores

CorefResultScores: { __typename?: "CorefResultScores"; mention?: Maybe<Scalars["String"]>; reference?: Maybe<Maybe<ResultScores>[]> }

Type declaration

  • Optional __typename?: "CorefResultScores"
  • Optional mention?: Maybe<Scalars["String"]>

    Cluster mention

  • Optional reference?: Maybe<Maybe<ResultScores>[]>

    Scores of the coreference resolution between mentions.

CorefScores

CorefScores: { __typename?: "CorefScores"; mention?: Maybe<Scalars["String"]>; scores?: Maybe<Maybe<Scores>[]> }

Type declaration

  • Optional __typename?: "CorefScores"
  • Optional mention?: Maybe<Scalars["String"]>

    Cluster mention

  • Optional scores?: Maybe<Maybe<Scores>[]>

    Scores of the coreference resolution between mentions.

Developers

Developers: { __typename?: "developers"; active: Scalars["Boolean"]; api_key: Scalars["String"]; apps: Apps[]; apps_aggregate: Apps_Aggregate; created_at: Scalars["timestamptz"]; email: Scalars["String"]; events: Events[]; events_aggregate: Events_Aggregate; github_handle?: Maybe<Scalars["String"]>; kv_stores: Kv_Store[]; kv_stores_aggregate: Kv_Store_Aggregate; metadata: Scalars["jsonb"]; name: Scalars["String"]; object_id: Scalars["Int"]; onboarded: Scalars["Boolean"]; uid: Scalars["String"] }

columns and relationships of "developers"

Type declaration

DevelopersAppsArgs

DevelopersAppsArgs: { distinct_on?: Maybe<Apps_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Apps_Order_By[]>; where?: Maybe<Apps_Bool_Exp> }

columns and relationships of "developers"

Type declaration

DevelopersApps_AggregateArgs

DevelopersApps_AggregateArgs: { distinct_on?: Maybe<Apps_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Apps_Order_By[]>; where?: Maybe<Apps_Bool_Exp> }

columns and relationships of "developers"

Type declaration

DevelopersEventsArgs

DevelopersEventsArgs: { distinct_on?: Maybe<Events_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Events_Order_By[]>; where?: Maybe<Events_Bool_Exp> }

columns and relationships of "developers"

Type declaration

DevelopersEvents_AggregateArgs

DevelopersEvents_AggregateArgs: { distinct_on?: Maybe<Events_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Events_Order_By[]>; where?: Maybe<Events_Bool_Exp> }

columns and relationships of "developers"

Type declaration

DevelopersKv_StoresArgs

DevelopersKv_StoresArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

columns and relationships of "developers"

Type declaration

DevelopersKv_Stores_AggregateArgs

DevelopersKv_Stores_AggregateArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

columns and relationships of "developers"

Type declaration

DevelopersMetadataArgs

DevelopersMetadataArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "developers"

Type declaration

Developers_Aggregate

Developers_Aggregate: { __typename?: "developers_aggregate"; aggregate?: Maybe<Developers_Aggregate_Fields>; nodes: Developers[] }

aggregated selection of "developers"

Type declaration

Developers_Aggregate_Fields

Developers_Aggregate_Fields: { __typename?: "developers_aggregate_fields"; avg?: Maybe<Developers_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<Developers_Max_Fields>; min?: Maybe<Developers_Min_Fields>; stddev?: Maybe<Developers_Stddev_Fields>; stddev_pop?: Maybe<Developers_Stddev_Pop_Fields>; stddev_samp?: Maybe<Developers_Stddev_Samp_Fields>; sum?: Maybe<Developers_Sum_Fields>; var_pop?: Maybe<Developers_Var_Pop_Fields>; var_samp?: Maybe<Developers_Var_Samp_Fields>; variance?: Maybe<Developers_Variance_Fields> }

aggregate fields of "developers"

Type declaration

Developers_Aggregate_FieldsCountArgs

Developers_Aggregate_FieldsCountArgs: { columns?: Maybe<Developers_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "developers"

Type declaration

Developers_Append_Input

Developers_Append_Input: { metadata?: Maybe<Scalars["jsonb"]> }

append existing jsonb value of filtered columns with new jsonb value

Type declaration

Developers_Avg_Fields

Developers_Avg_Fields: { __typename?: "developers_avg_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "developers_avg_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Developers_Bool_Exp

Boolean expression to filter rows from the table "developers". All fields are combined with a logical 'AND'.

Type declaration

Developers_Delete_At_Path_Input

Developers_Delete_At_Path_Input: { metadata?: Maybe<Scalars["String"][]> }

delete the field or element with specified path (for JSON arrays, negative integers count from the end)

Type declaration

Developers_Delete_Elem_Input

Developers_Delete_Elem_Input: { metadata?: Maybe<Scalars["Int"]> }

delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array

Type declaration

Developers_Delete_Key_Input

Developers_Delete_Key_Input: { metadata?: Maybe<Scalars["String"]> }

delete key/value pair or string element. key/value pairs are matched based on their key value

Type declaration

Developers_Inc_Input

Developers_Inc_Input: { object_id?: Maybe<Scalars["Int"]> }

input type for incrementing numeric columns in table "developers"

Type declaration

Developers_Insert_Input

Developers_Insert_Input: { active?: Maybe<Scalars["Boolean"]>; api_key?: Maybe<Scalars["String"]>; apps?: Maybe<Apps_Arr_Rel_Insert_Input>; created_at?: Maybe<Scalars["timestamptz"]>; email?: Maybe<Scalars["String"]>; events?: Maybe<Events_Arr_Rel_Insert_Input>; github_handle?: Maybe<Scalars["String"]>; kv_stores?: Maybe<Kv_Store_Arr_Rel_Insert_Input>; metadata?: Maybe<Scalars["jsonb"]>; name?: Maybe<Scalars["String"]>; object_id?: Maybe<Scalars["Int"]>; onboarded?: Maybe<Scalars["Boolean"]>; uid?: Maybe<Scalars["String"]> }

input type for inserting data into table "developers"

Type declaration

Developers_Max_Fields

Developers_Max_Fields: { __typename?: "developers_max_fields"; api_key?: Maybe<Scalars["String"]>; created_at?: Maybe<Scalars["timestamptz"]>; email?: Maybe<Scalars["String"]>; github_handle?: Maybe<Scalars["String"]>; name?: Maybe<Scalars["String"]>; object_id?: Maybe<Scalars["Int"]>; uid?: Maybe<Scalars["String"]> }

aggregate max on columns

Type declaration

Developers_Min_Fields

Developers_Min_Fields: { __typename?: "developers_min_fields"; api_key?: Maybe<Scalars["String"]>; created_at?: Maybe<Scalars["timestamptz"]>; email?: Maybe<Scalars["String"]>; github_handle?: Maybe<Scalars["String"]>; name?: Maybe<Scalars["String"]>; object_id?: Maybe<Scalars["Int"]>; uid?: Maybe<Scalars["String"]> }

aggregate min on columns

Type declaration

Developers_Mutation_Response

Developers_Mutation_Response: { __typename?: "developers_mutation_response"; affected_rows: Scalars["Int"]; returning: Developers[] }

response of any mutation on the table "developers"

Type declaration

  • Optional __typename?: "developers_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Developers[]

    data from the rows affected by the mutation

Developers_Obj_Rel_Insert_Input

Developers_Obj_Rel_Insert_Input: { data: Developers_Insert_Input; on_conflict?: Maybe<Developers_On_Conflict> }

input type for inserting object relation for remote table "developers"

Type declaration

Developers_On_Conflict

Developers_On_Conflict: { constraint: Developers_Constraint; update_columns: Developers_Update_Column[]; where?: Maybe<Developers_Bool_Exp> }

on conflict condition type for table "developers"

Type declaration

Developers_Order_By

Developers_Order_By: { active?: Maybe<Order_By>; api_key?: Maybe<Order_By>; apps_aggregate?: Maybe<Apps_Aggregate_Order_By>; created_at?: Maybe<Order_By>; email?: Maybe<Order_By>; events_aggregate?: Maybe<Events_Aggregate_Order_By>; github_handle?: Maybe<Order_By>; kv_stores_aggregate?: Maybe<Kv_Store_Aggregate_Order_By>; metadata?: Maybe<Order_By>; name?: Maybe<Order_By>; object_id?: Maybe<Order_By>; onboarded?: Maybe<Order_By>; uid?: Maybe<Order_By> }

Ordering options when selecting data from "developers".

Type declaration

Developers_Prepend_Input

Developers_Prepend_Input: { metadata?: Maybe<Scalars["jsonb"]> }

prepend existing jsonb value of filtered columns with new jsonb value

Type declaration

Developers_Set_Input

Developers_Set_Input: { active?: Maybe<Scalars["Boolean"]>; api_key?: Maybe<Scalars["String"]>; created_at?: Maybe<Scalars["timestamptz"]>; email?: Maybe<Scalars["String"]>; github_handle?: Maybe<Scalars["String"]>; metadata?: Maybe<Scalars["jsonb"]>; name?: Maybe<Scalars["String"]>; object_id?: Maybe<Scalars["Int"]>; onboarded?: Maybe<Scalars["Boolean"]>; uid?: Maybe<Scalars["String"]> }

input type for updating data in table "developers"

Type declaration

Developers_Stddev_Fields

Developers_Stddev_Fields: { __typename?: "developers_stddev_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "developers_stddev_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Developers_Stddev_Pop_Fields

Developers_Stddev_Pop_Fields: { __typename?: "developers_stddev_pop_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "developers_stddev_pop_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Developers_Stddev_Samp_Fields

Developers_Stddev_Samp_Fields: { __typename?: "developers_stddev_samp_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "developers_stddev_samp_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Developers_Sum_Fields

Developers_Sum_Fields: { __typename?: "developers_sum_fields"; object_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "developers_sum_fields"
  • Optional object_id?: Maybe<Scalars["Int"]>

Developers_Var_Pop_Fields

Developers_Var_Pop_Fields: { __typename?: "developers_var_pop_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "developers_var_pop_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Developers_Var_Samp_Fields

Developers_Var_Samp_Fields: { __typename?: "developers_var_samp_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "developers_var_samp_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Developers_Variance_Fields

Developers_Variance_Fields: { __typename?: "developers_variance_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "developers_variance_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

DialogAlternative

DialogAlternative: { __typename?: "DialogAlternative"; alternative?: Maybe<Scalars["String"]>; score?: Maybe<Scalars["Float"]> }

One of the alternatives, among which the next turn must be chosen

Type declaration

  • Optional __typename?: "DialogAlternative"
  • Optional alternative?: Maybe<Scalars["String"]>

    Content of the utterance

  • Optional score?: Maybe<Scalars["Float"]>

    Confidence of the utterance

DocExtension

DocExtension: { __typename?: "DocExtension"; coref_clusters?: Maybe<Maybe<CorefCluster>[]>; coref_resolved?: Maybe<Scalars["String"]>; coref_scores?: Maybe<Maybe<CorefScores>[]>; has_coref?: Maybe<Scalars["Boolean"]> }

Type declaration

  • Optional __typename?: "DocExtension"
  • Optional coref_clusters?: Maybe<Maybe<CorefCluster>[]>

    All the clusters of corefering mentions in the doc

  • Optional coref_resolved?: Maybe<Scalars["String"]>

    Unicode representation of the doc where each corefering mention is replaced by the main mention in the associated cluster.

  • Optional coref_scores?: Maybe<Maybe<CorefScores>[]>

    Scores of the coreference resolution between mentions.

  • Optional has_coref?: Maybe<Scalars["Boolean"]>

    Has any coreference has been resolved in the Doc

End_User_Conversations

End_User_Conversations: { __typename?: "end_user_conversations"; conversation: Conversations; conversation_id: Scalars["Int"]; end_user: End_Users; end_user_id: Scalars["Int"] }

columns and relationships of "end_user_conversations"

Type declaration

  • Optional __typename?: "end_user_conversations"
  • conversation: Conversations

    An object relationship

  • conversation_id: Scalars["Int"]
  • end_user: End_Users

    An object relationship

  • end_user_id: Scalars["Int"]

End_User_Conversations_Aggregate

End_User_Conversations_Aggregate: { __typename?: "end_user_conversations_aggregate"; aggregate?: Maybe<End_User_Conversations_Aggregate_Fields>; nodes: End_User_Conversations[] }

aggregated selection of "end_user_conversations"

Type declaration

End_User_Conversations_Aggregate_Fields

aggregate fields of "end_user_conversations"

Type declaration

End_User_Conversations_Aggregate_FieldsCountArgs

End_User_Conversations_Aggregate_FieldsCountArgs: { columns?: Maybe<End_User_Conversations_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "end_user_conversations"

Type declaration

End_User_Conversations_Aggregate_Order_By

order by aggregate values of table "end_user_conversations"

End_User_Conversations_Arr_Rel_Insert_Input

End_User_Conversations_Arr_Rel_Insert_Input: { data: End_User_Conversations_Insert_Input[]; on_conflict?: Maybe<End_User_Conversations_On_Conflict> }

input type for inserting array relation for remote table "end_user_conversations"

Type declaration

End_User_Conversations_Avg_Fields

End_User_Conversations_Avg_Fields: { __typename?: "end_user_conversations_avg_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "end_user_conversations_avg_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

End_User_Conversations_Avg_Order_By

End_User_Conversations_Avg_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by avg() on columns of table "end_user_conversations"

Type declaration

End_User_Conversations_Bool_Exp

End_User_Conversations_Bool_Exp: { _and?: Maybe<End_User_Conversations_Bool_Exp[]>; _not?: Maybe<End_User_Conversations_Bool_Exp>; _or?: Maybe<End_User_Conversations_Bool_Exp[]>; conversation?: Maybe<Conversations_Bool_Exp>; conversation_id?: Maybe<Int_Comparison_Exp>; end_user?: Maybe<End_Users_Bool_Exp>; end_user_id?: Maybe<Int_Comparison_Exp> }

Boolean expression to filter rows from the table "end_user_conversations". All fields are combined with a logical 'AND'.

Type declaration

End_User_Conversations_Inc_Input

End_User_Conversations_Inc_Input: { conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]> }

input type for incrementing numeric columns in table "end_user_conversations"

Type declaration

End_User_Conversations_Insert_Input

End_User_Conversations_Insert_Input: { conversation?: Maybe<Conversations_Obj_Rel_Insert_Input>; conversation_id?: Maybe<Scalars["Int"]>; end_user?: Maybe<End_Users_Obj_Rel_Insert_Input>; end_user_id?: Maybe<Scalars["Int"]> }

input type for inserting data into table "end_user_conversations"

Type declaration

End_User_Conversations_Max_Fields

End_User_Conversations_Max_Fields: { __typename?: "end_user_conversations_max_fields"; conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]> }

aggregate max on columns

Type declaration

  • Optional __typename?: "end_user_conversations_max_fields"
  • Optional conversation_id?: Maybe<Scalars["Int"]>
  • Optional end_user_id?: Maybe<Scalars["Int"]>

End_User_Conversations_Max_Order_By

End_User_Conversations_Max_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by max() on columns of table "end_user_conversations"

Type declaration

End_User_Conversations_Min_Fields

End_User_Conversations_Min_Fields: { __typename?: "end_user_conversations_min_fields"; conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]> }

aggregate min on columns

Type declaration

  • Optional __typename?: "end_user_conversations_min_fields"
  • Optional conversation_id?: Maybe<Scalars["Int"]>
  • Optional end_user_id?: Maybe<Scalars["Int"]>

End_User_Conversations_Min_Order_By

End_User_Conversations_Min_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by min() on columns of table "end_user_conversations"

Type declaration

End_User_Conversations_Mutation_Response

End_User_Conversations_Mutation_Response: { __typename?: "end_user_conversations_mutation_response"; affected_rows: Scalars["Int"]; returning: End_User_Conversations[] }

response of any mutation on the table "end_user_conversations"

Type declaration

  • Optional __typename?: "end_user_conversations_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: End_User_Conversations[]

    data from the rows affected by the mutation

End_User_Conversations_On_Conflict

End_User_Conversations_On_Conflict: { constraint: End_User_Conversations_Constraint; update_columns: End_User_Conversations_Update_Column[]; where?: Maybe<End_User_Conversations_Bool_Exp> }

on conflict condition type for table "end_user_conversations"

Type declaration

End_User_Conversations_Order_By

End_User_Conversations_Order_By: { conversation?: Maybe<Conversations_Order_By>; conversation_id?: Maybe<Order_By>; end_user?: Maybe<End_Users_Order_By>; end_user_id?: Maybe<Order_By> }

Ordering options when selecting data from "end_user_conversations".

Type declaration

End_User_Conversations_Pk_Columns_Input

End_User_Conversations_Pk_Columns_Input: { conversation_id: Scalars["Int"]; end_user_id: Scalars["Int"] }

primary key columns input for table: end_user_conversations

Type declaration

End_User_Conversations_Set_Input

End_User_Conversations_Set_Input: { conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]> }

input type for updating data in table "end_user_conversations"

Type declaration

End_User_Conversations_Stddev_Fields

End_User_Conversations_Stddev_Fields: { __typename?: "end_user_conversations_stddev_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "end_user_conversations_stddev_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

End_User_Conversations_Stddev_Order_By

End_User_Conversations_Stddev_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by stddev() on columns of table "end_user_conversations"

Type declaration

End_User_Conversations_Stddev_Pop_Fields

End_User_Conversations_Stddev_Pop_Fields: { __typename?: "end_user_conversations_stddev_pop_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "end_user_conversations_stddev_pop_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

End_User_Conversations_Stddev_Pop_Order_By

End_User_Conversations_Stddev_Pop_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by stddev_pop() on columns of table "end_user_conversations"

Type declaration

End_User_Conversations_Stddev_Samp_Fields

End_User_Conversations_Stddev_Samp_Fields: { __typename?: "end_user_conversations_stddev_samp_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "end_user_conversations_stddev_samp_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

End_User_Conversations_Stddev_Samp_Order_By

End_User_Conversations_Stddev_Samp_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by stddev_samp() on columns of table "end_user_conversations"

Type declaration

End_User_Conversations_Sum_Fields

End_User_Conversations_Sum_Fields: { __typename?: "end_user_conversations_sum_fields"; conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "end_user_conversations_sum_fields"
  • Optional conversation_id?: Maybe<Scalars["Int"]>
  • Optional end_user_id?: Maybe<Scalars["Int"]>

End_User_Conversations_Sum_Order_By

End_User_Conversations_Sum_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by sum() on columns of table "end_user_conversations"

Type declaration

End_User_Conversations_Var_Pop_Fields

End_User_Conversations_Var_Pop_Fields: { __typename?: "end_user_conversations_var_pop_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "end_user_conversations_var_pop_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

End_User_Conversations_Var_Pop_Order_By

End_User_Conversations_Var_Pop_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by var_pop() on columns of table "end_user_conversations"

Type declaration

End_User_Conversations_Var_Samp_Fields

End_User_Conversations_Var_Samp_Fields: { __typename?: "end_user_conversations_var_samp_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "end_user_conversations_var_samp_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

End_User_Conversations_Var_Samp_Order_By

End_User_Conversations_Var_Samp_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by var_samp() on columns of table "end_user_conversations"

Type declaration

End_User_Conversations_Variance_Fields

End_User_Conversations_Variance_Fields: { __typename?: "end_user_conversations_variance_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "end_user_conversations_variance_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

End_User_Conversations_Variance_Order_By

End_User_Conversations_Variance_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by variance() on columns of table "end_user_conversations"

Type declaration

End_Users

End_Users: { __typename?: "end_users"; conversations: Conversations[]; conversations_aggregate: Conversations_Aggregate; created_at: Scalars["timestamptz"]; end_user_conversations: End_User_Conversations[]; end_user_conversations_aggregate: End_User_Conversations_Aggregate; kv_store: Kv_Store[]; kv_store_aggregate: Kv_Store_Aggregate; metadata: Scalars["jsonb"]; object_id: Scalars["Int"]; scope_name?: Maybe<Scalars["String"]>; utterances: Utterances[]; utterances_aggregate: Utterances_Aggregate; uuid: Scalars["String"] }

columns and relationships of "end_users"

Type declaration

End_UsersConversationsArgs

End_UsersConversationsArgs: { distinct_on?: Maybe<Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conversations_Order_By[]>; where?: Maybe<Conversations_Bool_Exp> }

columns and relationships of "end_users"

Type declaration

End_UsersConversations_AggregateArgs

End_UsersConversations_AggregateArgs: { distinct_on?: Maybe<Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conversations_Order_By[]>; where?: Maybe<Conversations_Bool_Exp> }

columns and relationships of "end_users"

Type declaration

End_UsersEnd_User_ConversationsArgs

End_UsersEnd_User_ConversationsArgs: { distinct_on?: Maybe<End_User_Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_User_Conversations_Order_By[]>; where?: Maybe<End_User_Conversations_Bool_Exp> }

columns and relationships of "end_users"

Type declaration

End_UsersEnd_User_Conversations_AggregateArgs

End_UsersEnd_User_Conversations_AggregateArgs: { distinct_on?: Maybe<End_User_Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_User_Conversations_Order_By[]>; where?: Maybe<End_User_Conversations_Bool_Exp> }

columns and relationships of "end_users"

Type declaration

End_UsersKv_StoreArgs

End_UsersKv_StoreArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

columns and relationships of "end_users"

Type declaration

End_UsersKv_Store_AggregateArgs

End_UsersKv_Store_AggregateArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

columns and relationships of "end_users"

Type declaration

End_UsersMetadataArgs

End_UsersMetadataArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "end_users"

Type declaration

End_UsersUtterancesArgs

End_UsersUtterancesArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

columns and relationships of "end_users"

Type declaration

End_UsersUtterances_AggregateArgs

End_UsersUtterances_AggregateArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

columns and relationships of "end_users"

Type declaration

End_Users_Aggregate

End_Users_Aggregate: { __typename?: "end_users_aggregate"; aggregate?: Maybe<End_Users_Aggregate_Fields>; nodes: End_Users[] }

aggregated selection of "end_users"

Type declaration

End_Users_Aggregate_Fields

End_Users_Aggregate_Fields: { __typename?: "end_users_aggregate_fields"; avg?: Maybe<End_Users_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<End_Users_Max_Fields>; min?: Maybe<End_Users_Min_Fields>; stddev?: Maybe<End_Users_Stddev_Fields>; stddev_pop?: Maybe<End_Users_Stddev_Pop_Fields>; stddev_samp?: Maybe<End_Users_Stddev_Samp_Fields>; sum?: Maybe<End_Users_Sum_Fields>; var_pop?: Maybe<End_Users_Var_Pop_Fields>; var_samp?: Maybe<End_Users_Var_Samp_Fields>; variance?: Maybe<End_Users_Variance_Fields> }

aggregate fields of "end_users"

Type declaration

End_Users_Aggregate_FieldsCountArgs

End_Users_Aggregate_FieldsCountArgs: { columns?: Maybe<End_Users_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "end_users"

Type declaration

End_Users_Append_Input

End_Users_Append_Input: { metadata?: Maybe<Scalars["jsonb"]> }

append existing jsonb value of filtered columns with new jsonb value

Type declaration

End_Users_Avg_Fields

End_Users_Avg_Fields: { __typename?: "end_users_avg_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "end_users_avg_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

End_Users_Bool_Exp

End_Users_Bool_Exp: { _and?: Maybe<End_Users_Bool_Exp[]>; _not?: Maybe<End_Users_Bool_Exp>; _or?: Maybe<End_Users_Bool_Exp[]>; conversations?: Maybe<Conversations_Bool_Exp>; created_at?: Maybe<Timestamptz_Comparison_Exp>; end_user_conversations?: Maybe<End_User_Conversations_Bool_Exp>; kv_store?: Maybe<Kv_Store_Bool_Exp>; metadata?: Maybe<Jsonb_Comparison_Exp>; object_id?: Maybe<Int_Comparison_Exp>; scope_name?: Maybe<String_Comparison_Exp>; utterances?: Maybe<Utterances_Bool_Exp>; uuid?: Maybe<String_Comparison_Exp> }

Boolean expression to filter rows from the table "end_users". All fields are combined with a logical 'AND'.

Type declaration

End_Users_Delete_At_Path_Input

End_Users_Delete_At_Path_Input: { metadata?: Maybe<Scalars["String"][]> }

delete the field or element with specified path (for JSON arrays, negative integers count from the end)

Type declaration

End_Users_Delete_Elem_Input

End_Users_Delete_Elem_Input: { metadata?: Maybe<Scalars["Int"]> }

delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array

Type declaration

End_Users_Delete_Key_Input

End_Users_Delete_Key_Input: { metadata?: Maybe<Scalars["String"]> }

delete key/value pair or string element. key/value pairs are matched based on their key value

Type declaration

End_Users_Inc_Input

End_Users_Inc_Input: { object_id?: Maybe<Scalars["Int"]> }

input type for incrementing numeric columns in table "end_users"

Type declaration

End_Users_Insert_Input

End_Users_Insert_Input: { conversations?: Maybe<Conversations_Arr_Rel_Insert_Input>; created_at?: Maybe<Scalars["timestamptz"]>; end_user_conversations?: Maybe<End_User_Conversations_Arr_Rel_Insert_Input>; kv_store?: Maybe<Kv_Store_Arr_Rel_Insert_Input>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]>; utterances?: Maybe<Utterances_Arr_Rel_Insert_Input>; uuid?: Maybe<Scalars["String"]> }

input type for inserting data into table "end_users"

Type declaration

End_Users_Max_Fields

End_Users_Max_Fields: { __typename?: "end_users_max_fields"; created_at?: Maybe<Scalars["timestamptz"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]>; uuid?: Maybe<Scalars["String"]> }

aggregate max on columns

Type declaration

End_Users_Min_Fields

End_Users_Min_Fields: { __typename?: "end_users_min_fields"; created_at?: Maybe<Scalars["timestamptz"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]>; uuid?: Maybe<Scalars["String"]> }

aggregate min on columns

Type declaration

End_Users_Mutation_Response

End_Users_Mutation_Response: { __typename?: "end_users_mutation_response"; affected_rows: Scalars["Int"]; returning: End_Users[] }

response of any mutation on the table "end_users"

Type declaration

  • Optional __typename?: "end_users_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: End_Users[]

    data from the rows affected by the mutation

End_Users_Obj_Rel_Insert_Input

End_Users_Obj_Rel_Insert_Input: { data: End_Users_Insert_Input; on_conflict?: Maybe<End_Users_On_Conflict> }

input type for inserting object relation for remote table "end_users"

Type declaration

End_Users_On_Conflict

End_Users_On_Conflict: { constraint: End_Users_Constraint; update_columns: End_Users_Update_Column[]; where?: Maybe<End_Users_Bool_Exp> }

on conflict condition type for table "end_users"

Type declaration

End_Users_Order_By

End_Users_Order_By: { conversations_aggregate?: Maybe<Conversations_Aggregate_Order_By>; created_at?: Maybe<Order_By>; end_user_conversations_aggregate?: Maybe<End_User_Conversations_Aggregate_Order_By>; kv_store_aggregate?: Maybe<Kv_Store_Aggregate_Order_By>; metadata?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_name?: Maybe<Order_By>; utterances_aggregate?: Maybe<Utterances_Aggregate_Order_By>; uuid?: Maybe<Order_By> }

Ordering options when selecting data from "end_users".

Type declaration

End_Users_Prepend_Input

End_Users_Prepend_Input: { metadata?: Maybe<Scalars["jsonb"]> }

prepend existing jsonb value of filtered columns with new jsonb value

Type declaration

End_Users_Set_Input

End_Users_Set_Input: { created_at?: Maybe<Scalars["timestamptz"]>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]>; scope_name?: Maybe<Scalars["String"]>; uuid?: Maybe<Scalars["String"]> }

input type for updating data in table "end_users"

Type declaration

End_Users_Stddev_Fields

End_Users_Stddev_Fields: { __typename?: "end_users_stddev_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "end_users_stddev_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

End_Users_Stddev_Pop_Fields

End_Users_Stddev_Pop_Fields: { __typename?: "end_users_stddev_pop_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "end_users_stddev_pop_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

End_Users_Stddev_Samp_Fields

End_Users_Stddev_Samp_Fields: { __typename?: "end_users_stddev_samp_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "end_users_stddev_samp_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

End_Users_Sum_Fields

End_Users_Sum_Fields: { __typename?: "end_users_sum_fields"; object_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "end_users_sum_fields"
  • Optional object_id?: Maybe<Scalars["Int"]>

End_Users_Var_Pop_Fields

End_Users_Var_Pop_Fields: { __typename?: "end_users_var_pop_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "end_users_var_pop_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

End_Users_Var_Samp_Fields

End_Users_Var_Samp_Fields: { __typename?: "end_users_var_samp_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "end_users_var_samp_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

End_Users_Variance_Fields

End_Users_Variance_Fields: { __typename?: "end_users_variance_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "end_users_variance_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

EntityFieldsFragment

EntityFieldsFragment: { __typename?: "NLUSpan" } & Pick<NluSpan, "has_vector" | "vector" | "vector_norm">

EntityResultFieldsFragment

EntityResultFieldsFragment: { __typename?: "NLUResult" } & Pick<NluResult, "has_vector" | "vector" | "vector_norm">

EntitySubtreeFragment

EntitySubtreeFragment: { __typename?: "NLUSpan" } & { entities?: Maybe<Maybe<{ __typename?: "NLUSpan" } & { entities?: Maybe<Maybe<{ __typename?: "NLUSpan" } & { entities?: Maybe<Maybe<{ __typename?: "NLUSpan" } & { entities?: Maybe<Maybe<{ __typename?: "NLUSpan" } & EntityFieldsFragment>[]> } & EntityFieldsFragment>[]> } & EntityFieldsFragment>[]> } & EntityFieldsFragment>[]> } & EntityFieldsFragment

Events

Events: { __typename?: "events"; action?: Maybe<Scalars["String"]>; changed_fields?: Maybe<Scalars["jsonb"]>; developer_id?: Maybe<Scalars["String"]>; table?: Maybe<Scalars["String"]>; timestamp?: Maybe<Scalars["timestamptz"]> }

columns and relationships of "events"

Type declaration

EventsChanged_FieldsArgs

EventsChanged_FieldsArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "events"

Type declaration

Events_Aggregate

Events_Aggregate: { __typename?: "events_aggregate"; aggregate?: Maybe<Events_Aggregate_Fields>; nodes: Events[] }

aggregated selection of "events"

Type declaration

Events_Aggregate_Fields

Events_Aggregate_Fields: { __typename?: "events_aggregate_fields"; count: Scalars["Int"]; max?: Maybe<Events_Max_Fields>; min?: Maybe<Events_Min_Fields> }

aggregate fields of "events"

Type declaration

Events_Aggregate_FieldsCountArgs

Events_Aggregate_FieldsCountArgs: { columns?: Maybe<Events_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "events"

Type declaration

Events_Aggregate_Order_By

Events_Aggregate_Order_By: { count?: Maybe<Order_By>; max?: Maybe<Events_Max_Order_By>; min?: Maybe<Events_Min_Order_By> }

order by aggregate values of table "events"

Type declaration

Events_Append_Input

Events_Append_Input: { changed_fields?: Maybe<Scalars["jsonb"]> }

append existing jsonb value of filtered columns with new jsonb value

Type declaration

Events_Arr_Rel_Insert_Input

Events_Arr_Rel_Insert_Input: { data: Events_Insert_Input[] }

input type for inserting array relation for remote table "events"

Type declaration

Events_Bool_Exp

Events_Bool_Exp: { _and?: Maybe<Events_Bool_Exp[]>; _not?: Maybe<Events_Bool_Exp>; _or?: Maybe<Events_Bool_Exp[]>; action?: Maybe<String_Comparison_Exp>; changed_fields?: Maybe<Jsonb_Comparison_Exp>; developer_id?: Maybe<String_Comparison_Exp>; table?: Maybe<String_Comparison_Exp>; timestamp?: Maybe<Timestamptz_Comparison_Exp> }

Boolean expression to filter rows from the table "events". All fields are combined with a logical 'AND'.

Type declaration

Events_Delete_At_Path_Input

Events_Delete_At_Path_Input: { changed_fields?: Maybe<Scalars["String"][]> }

delete the field or element with specified path (for JSON arrays, negative integers count from the end)

Type declaration

Events_Delete_Elem_Input

Events_Delete_Elem_Input: { changed_fields?: Maybe<Scalars["Int"]> }

delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array

Type declaration

Events_Delete_Key_Input

Events_Delete_Key_Input: { changed_fields?: Maybe<Scalars["String"]> }

delete key/value pair or string element. key/value pairs are matched based on their key value

Type declaration

Events_Insert_Input

Events_Insert_Input: { action?: Maybe<Scalars["String"]>; changed_fields?: Maybe<Scalars["jsonb"]>; developer_id?: Maybe<Scalars["String"]>; table?: Maybe<Scalars["String"]>; timestamp?: Maybe<Scalars["timestamptz"]> }

input type for inserting data into table "events"

Type declaration

Events_Max_Fields

Events_Max_Fields: { __typename?: "events_max_fields"; action?: Maybe<Scalars["String"]>; developer_id?: Maybe<Scalars["String"]>; table?: Maybe<Scalars["String"]>; timestamp?: Maybe<Scalars["timestamptz"]> }

aggregate max on columns

Type declaration

Events_Max_Order_By

Events_Max_Order_By: { action?: Maybe<Order_By>; developer_id?: Maybe<Order_By>; table?: Maybe<Order_By>; timestamp?: Maybe<Order_By> }

order by max() on columns of table "events"

Type declaration

Events_Min_Fields

Events_Min_Fields: { __typename?: "events_min_fields"; action?: Maybe<Scalars["String"]>; developer_id?: Maybe<Scalars["String"]>; table?: Maybe<Scalars["String"]>; timestamp?: Maybe<Scalars["timestamptz"]> }

aggregate min on columns

Type declaration

Events_Min_Order_By

Events_Min_Order_By: { action?: Maybe<Order_By>; developer_id?: Maybe<Order_By>; table?: Maybe<Order_By>; timestamp?: Maybe<Order_By> }

order by min() on columns of table "events"

Type declaration

Events_Mutation_Response

Events_Mutation_Response: { __typename?: "events_mutation_response"; affected_rows: Scalars["Int"]; returning: Events[] }

response of any mutation on the table "events"

Type declaration

  • Optional __typename?: "events_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Events[]

    data from the rows affected by the mutation

Events_Order_By

Events_Order_By: { action?: Maybe<Order_By>; changed_fields?: Maybe<Order_By>; developer_id?: Maybe<Order_By>; table?: Maybe<Order_By>; timestamp?: Maybe<Order_By> }

Ordering options when selecting data from "events".

Type declaration

Events_Prepend_Input

Events_Prepend_Input: { changed_fields?: Maybe<Scalars["jsonb"]> }

prepend existing jsonb value of filtered columns with new jsonb value

Type declaration

Events_Set_Input

Events_Set_Input: { action?: Maybe<Scalars["String"]>; changed_fields?: Maybe<Scalars["jsonb"]>; developer_id?: Maybe<Scalars["String"]>; table?: Maybe<Scalars["String"]>; timestamp?: Maybe<Scalars["timestamptz"]> }

input type for updating data in table "events"

Type declaration

Exact

Exact<T>: {[ K in keyof T]: T[K] }

Type parameters

  • T: {}

GetConceptnetRelationsQuery

GetConceptnetRelationsQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "RelationResult" } & { predictions: RelationResult["result"] }> }

GetConceptnetRelationsQueryVariables

GetConceptnetRelationsQueryVariables: Exact<{ input: Scalars["String"]; relation: Relation }>

GetSentimentQuery

GetSentimentQuery: { __typename?: "query_root" } & { result?: Maybe<Maybe<{ __typename?: "SentimentAnalysisResult" } & Pick<SentimentAnalysisResult, "label" | "score">>[]> }

GetSentimentQueryVariables

GetSentimentQueryVariables: Exact<{ input: Scalars["String"] }>

History

History: { __typename?: "history"; conversation?: Maybe<Conversations>; conversation_id?: Maybe<Scalars["Int"]>; interval?: Maybe<Scalars["timestamptz"]>; updated_at?: Maybe<Scalars["timestamptz"]>; utterances?: Maybe<Scalars["jsonb"]>; window?: Maybe<Scalars["tstzrange"]> }

columns and relationships of "history"

Type declaration

HistoryUtterancesArgs

HistoryUtterancesArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "history"

Type declaration

History_Aggregate

History_Aggregate: { __typename?: "history_aggregate"; aggregate?: Maybe<History_Aggregate_Fields>; nodes: History[] }

aggregated selection of "history"

Type declaration

History_Aggregate_Fields

History_Aggregate_Fields: { __typename?: "history_aggregate_fields"; avg?: Maybe<History_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<History_Max_Fields>; min?: Maybe<History_Min_Fields>; stddev?: Maybe<History_Stddev_Fields>; stddev_pop?: Maybe<History_Stddev_Pop_Fields>; stddev_samp?: Maybe<History_Stddev_Samp_Fields>; sum?: Maybe<History_Sum_Fields>; var_pop?: Maybe<History_Var_Pop_Fields>; var_samp?: Maybe<History_Var_Samp_Fields>; variance?: Maybe<History_Variance_Fields> }

aggregate fields of "history"

Type declaration

History_Aggregate_FieldsCountArgs

History_Aggregate_FieldsCountArgs: { columns?: Maybe<History_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "history"

Type declaration

History_Avg_Fields

History_Avg_Fields: { __typename?: "history_avg_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "history_avg_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

History_Bool_Exp

History_Bool_Exp: { _and?: Maybe<History_Bool_Exp[]>; _not?: Maybe<History_Bool_Exp>; _or?: Maybe<History_Bool_Exp[]>; conversation?: Maybe<Conversations_Bool_Exp>; conversation_id?: Maybe<Int_Comparison_Exp>; interval?: Maybe<Timestamptz_Comparison_Exp>; updated_at?: Maybe<Timestamptz_Comparison_Exp>; utterances?: Maybe<Jsonb_Comparison_Exp>; window?: Maybe<Tstzrange_Comparison_Exp> }

Boolean expression to filter rows from the table "history". All fields are combined with a logical 'AND'.

Type declaration

History_Max_Fields

History_Max_Fields: { __typename?: "history_max_fields"; conversation_id?: Maybe<Scalars["Int"]>; interval?: Maybe<Scalars["timestamptz"]>; updated_at?: Maybe<Scalars["timestamptz"]> }

aggregate max on columns

Type declaration

  • Optional __typename?: "history_max_fields"
  • Optional conversation_id?: Maybe<Scalars["Int"]>
  • Optional interval?: Maybe<Scalars["timestamptz"]>
  • Optional updated_at?: Maybe<Scalars["timestamptz"]>

History_Min_Fields

History_Min_Fields: { __typename?: "history_min_fields"; conversation_id?: Maybe<Scalars["Int"]>; interval?: Maybe<Scalars["timestamptz"]>; updated_at?: Maybe<Scalars["timestamptz"]> }

aggregate min on columns

Type declaration

  • Optional __typename?: "history_min_fields"
  • Optional conversation_id?: Maybe<Scalars["Int"]>
  • Optional interval?: Maybe<Scalars["timestamptz"]>
  • Optional updated_at?: Maybe<Scalars["timestamptz"]>

History_Order_By

History_Order_By: { conversation?: Maybe<Conversations_Order_By>; conversation_id?: Maybe<Order_By>; interval?: Maybe<Order_By>; updated_at?: Maybe<Order_By>; utterances?: Maybe<Order_By>; window?: Maybe<Order_By> }

Ordering options when selecting data from "history".

Type declaration

History_Stddev_Fields

History_Stddev_Fields: { __typename?: "history_stddev_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "history_stddev_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

History_Stddev_Pop_Fields

History_Stddev_Pop_Fields: { __typename?: "history_stddev_pop_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "history_stddev_pop_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

History_Stddev_Samp_Fields

History_Stddev_Samp_Fields: { __typename?: "history_stddev_samp_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "history_stddev_samp_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

History_Sum_Fields

History_Sum_Fields: { __typename?: "history_sum_fields"; conversation_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "history_sum_fields"
  • Optional conversation_id?: Maybe<Scalars["Int"]>

History_Var_Pop_Fields

History_Var_Pop_Fields: { __typename?: "history_var_pop_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "history_var_pop_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

History_Var_Samp_Fields

History_Var_Samp_Fields: { __typename?: "history_var_samp_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "history_var_samp_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

History_Variance_Fields

History_Variance_Fields: { __typename?: "history_variance_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "history_variance_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

Inet_Comparison_Exp

Inet_Comparison_Exp: { _eq?: Maybe<Scalars["inet"]>; _gt?: Maybe<Scalars["inet"]>; _gte?: Maybe<Scalars["inet"]>; _in?: Maybe<Scalars["inet"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["inet"]>; _lte?: Maybe<Scalars["inet"]>; _neq?: Maybe<Scalars["inet"]>; _nin?: Maybe<Scalars["inet"][]> }

Boolean expression to compare columns of type "inet". All fields are combined with logical 'AND'.

Type declaration

InputPipe

InputPipe: { context?: Maybe<Scalars["JSON"]>; op?: Maybe<Scalars["String"]>; transform?: Maybe<Scalars["String"]> }

Pipe input type

Type declaration

  • Optional context?: Maybe<Scalars["JSON"]>

    Variable bindings

  • Optional op?: Maybe<Scalars["String"]>

    Service query name

  • Optional transform?: Maybe<Scalars["String"]>

    Transform logic

Int_Comparison_Exp

Int_Comparison_Exp: { _eq?: Maybe<Scalars["Int"]>; _gt?: Maybe<Scalars["Int"]>; _gte?: Maybe<Scalars["Int"]>; _in?: Maybe<Scalars["Int"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["Int"]>; _lte?: Maybe<Scalars["Int"]>; _neq?: Maybe<Scalars["Int"]>; _nin?: Maybe<Scalars["Int"][]> }

Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'.

Type declaration

Jsonb_Comparison_Exp

Jsonb_Comparison_Exp: { _contained_in?: Maybe<Scalars["jsonb"]>; _contains?: Maybe<Scalars["jsonb"]>; _eq?: Maybe<Scalars["jsonb"]>; _gt?: Maybe<Scalars["jsonb"]>; _gte?: Maybe<Scalars["jsonb"]>; _has_key?: Maybe<Scalars["String"]>; _has_keys_all?: Maybe<Scalars["String"][]>; _has_keys_any?: Maybe<Scalars["String"][]>; _in?: Maybe<Scalars["jsonb"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["jsonb"]>; _lte?: Maybe<Scalars["jsonb"]>; _neq?: Maybe<Scalars["jsonb"]>; _nin?: Maybe<Scalars["jsonb"][]> }

Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'.

Type declaration

  • Optional _contained_in?: Maybe<Scalars["jsonb"]>

    is the column contained in the given json value

  • Optional _contains?: Maybe<Scalars["jsonb"]>

    does the column contain the given json value at the top level

  • Optional _eq?: Maybe<Scalars["jsonb"]>
  • Optional _gt?: Maybe<Scalars["jsonb"]>
  • Optional _gte?: Maybe<Scalars["jsonb"]>
  • Optional _has_key?: Maybe<Scalars["String"]>

    does the string exist as a top-level key in the column

  • Optional _has_keys_all?: Maybe<Scalars["String"][]>

    do all of these strings exist as top-level keys in the column

  • Optional _has_keys_any?: Maybe<Scalars["String"][]>

    do any of these strings exist as top-level keys in the column

  • Optional _in?: Maybe<Scalars["jsonb"][]>
  • Optional _is_null?: Maybe<Scalars["Boolean"]>
  • Optional _lt?: Maybe<Scalars["jsonb"]>
  • Optional _lte?: Maybe<Scalars["jsonb"]>
  • Optional _neq?: Maybe<Scalars["jsonb"]>
  • Optional _nin?: Maybe<Scalars["jsonb"][]>

Kv_Scope_Enum

Kv_Scope_Enum: { __typename?: "kv_scope_enum"; value: Scalars["String"] }

columns and relationships of "kv_scope_enum"

Type declaration

  • Optional __typename?: "kv_scope_enum"
  • value: Scalars["String"]

Kv_Scope_Enum_Aggregate

Kv_Scope_Enum_Aggregate: { __typename?: "kv_scope_enum_aggregate"; aggregate?: Maybe<Kv_Scope_Enum_Aggregate_Fields>; nodes: Kv_Scope_Enum[] }

aggregated selection of "kv_scope_enum"

Type declaration

Kv_Scope_Enum_Aggregate_Fields

Kv_Scope_Enum_Aggregate_Fields: { __typename?: "kv_scope_enum_aggregate_fields"; count: Scalars["Int"]; max?: Maybe<Kv_Scope_Enum_Max_Fields>; min?: Maybe<Kv_Scope_Enum_Min_Fields> }

aggregate fields of "kv_scope_enum"

Type declaration

Kv_Scope_Enum_Aggregate_FieldsCountArgs

Kv_Scope_Enum_Aggregate_FieldsCountArgs: { columns?: Maybe<Kv_Scope_Enum_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "kv_scope_enum"

Type declaration

Kv_Scope_Enum_Bool_Exp

Kv_Scope_Enum_Bool_Exp: { _and?: Maybe<Kv_Scope_Enum_Bool_Exp[]>; _not?: Maybe<Kv_Scope_Enum_Bool_Exp>; _or?: Maybe<Kv_Scope_Enum_Bool_Exp[]>; value?: Maybe<String_Comparison_Exp> }

Boolean expression to filter rows from the table "kv_scope_enum". All fields are combined with a logical 'AND'.

Type declaration

Kv_Scope_Enum_Insert_Input

Kv_Scope_Enum_Insert_Input: { value?: Maybe<Scalars["String"]> }

input type for inserting data into table "kv_scope_enum"

Type declaration

Kv_Scope_Enum_Max_Fields

Kv_Scope_Enum_Max_Fields: { __typename?: "kv_scope_enum_max_fields"; value?: Maybe<Scalars["String"]> }

aggregate max on columns

Type declaration

  • Optional __typename?: "kv_scope_enum_max_fields"
  • Optional value?: Maybe<Scalars["String"]>

Kv_Scope_Enum_Min_Fields

Kv_Scope_Enum_Min_Fields: { __typename?: "kv_scope_enum_min_fields"; value?: Maybe<Scalars["String"]> }

aggregate min on columns

Type declaration

  • Optional __typename?: "kv_scope_enum_min_fields"
  • Optional value?: Maybe<Scalars["String"]>

Kv_Scope_Enum_Mutation_Response

Kv_Scope_Enum_Mutation_Response: { __typename?: "kv_scope_enum_mutation_response"; affected_rows: Scalars["Int"]; returning: Kv_Scope_Enum[] }

response of any mutation on the table "kv_scope_enum"

Type declaration

  • Optional __typename?: "kv_scope_enum_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Kv_Scope_Enum[]

    data from the rows affected by the mutation

Kv_Scope_Enum_On_Conflict

Kv_Scope_Enum_On_Conflict: { constraint: Kv_Scope_Enum_Constraint; update_columns: Kv_Scope_Enum_Update_Column[]; where?: Maybe<Kv_Scope_Enum_Bool_Exp> }

on conflict condition type for table "kv_scope_enum"

Type declaration

Kv_Scope_Enum_Order_By

Kv_Scope_Enum_Order_By: { value?: Maybe<Order_By> }

Ordering options when selecting data from "kv_scope_enum".

Type declaration

Kv_Scope_Enum_Pk_Columns_Input

Kv_Scope_Enum_Pk_Columns_Input: { value: Scalars["String"] }

primary key columns input for table: kv_scope_enum

Type declaration

Kv_Scope_Enum_Set_Input

Kv_Scope_Enum_Set_Input: { value?: Maybe<Scalars["String"]> }

input type for updating data in table "kv_scope_enum"

Type declaration

Kv_Store

Kv_Store: { __typename?: "kv_store"; created_at: Scalars["timestamptz"]; created_by: Scalars["Int"]; developer: Developers; key: Scalars["String"]; metadata: Scalars["jsonb"]; object_id: Scalars["Int"]; scope: Scalars["String"]; scope_object_id: Scalars["Int"]; updated_at: Scalars["timestamptz"]; value: Scalars["jsonb"] }

columns and relationships of "kv_store"

Type declaration

Kv_StoreMetadataArgs

Kv_StoreMetadataArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "kv_store"

Type declaration

Kv_StoreValueArgs

Kv_StoreValueArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "kv_store"

Type declaration

Kv_Store_Aggregate

Kv_Store_Aggregate: { __typename?: "kv_store_aggregate"; aggregate?: Maybe<Kv_Store_Aggregate_Fields>; nodes: Kv_Store[] }

aggregated selection of "kv_store"

Type declaration

Kv_Store_Aggregate_Fields

Kv_Store_Aggregate_Fields: { __typename?: "kv_store_aggregate_fields"; avg?: Maybe<Kv_Store_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<Kv_Store_Max_Fields>; min?: Maybe<Kv_Store_Min_Fields>; stddev?: Maybe<Kv_Store_Stddev_Fields>; stddev_pop?: Maybe<Kv_Store_Stddev_Pop_Fields>; stddev_samp?: Maybe<Kv_Store_Stddev_Samp_Fields>; sum?: Maybe<Kv_Store_Sum_Fields>; var_pop?: Maybe<Kv_Store_Var_Pop_Fields>; var_samp?: Maybe<Kv_Store_Var_Samp_Fields>; variance?: Maybe<Kv_Store_Variance_Fields> }

aggregate fields of "kv_store"

Type declaration

Kv_Store_Aggregate_FieldsCountArgs

Kv_Store_Aggregate_FieldsCountArgs: { columns?: Maybe<Kv_Store_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "kv_store"

Type declaration

Kv_Store_Aggregate_Order_By

order by aggregate values of table "kv_store"

Type declaration

Kv_Store_Append_Input

Kv_Store_Append_Input: { metadata?: Maybe<Scalars["jsonb"]>; value?: Maybe<Scalars["jsonb"]> }

append existing jsonb value of filtered columns with new jsonb value

Type declaration

Kv_Store_Arr_Rel_Insert_Input

Kv_Store_Arr_Rel_Insert_Input: { data: Kv_Store_Insert_Input[]; on_conflict?: Maybe<Kv_Store_On_Conflict> }

input type for inserting array relation for remote table "kv_store"

Type declaration

Kv_Store_Avg_Fields

Kv_Store_Avg_Fields: { __typename?: "kv_store_avg_fields"; created_by?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]>; scope_object_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "kv_store_avg_fields"
  • Optional created_by?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>
  • Optional scope_object_id?: Maybe<Scalars["Float"]>

Kv_Store_Avg_Order_By

Kv_Store_Avg_Order_By: { created_by?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By> }

order by avg() on columns of table "kv_store"

Type declaration

Kv_Store_Bool_Exp

Boolean expression to filter rows from the table "kv_store". All fields are combined with a logical 'AND'.

Type declaration

Kv_Store_Delete_At_Path_Input

Kv_Store_Delete_At_Path_Input: { metadata?: Maybe<Scalars["String"][]>; value?: Maybe<Scalars["String"][]> }

delete the field or element with specified path (for JSON arrays, negative integers count from the end)

Type declaration

Kv_Store_Delete_Elem_Input

Kv_Store_Delete_Elem_Input: { metadata?: Maybe<Scalars["Int"]>; value?: Maybe<Scalars["Int"]> }

delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array

Type declaration

Kv_Store_Delete_Key_Input

Kv_Store_Delete_Key_Input: { metadata?: Maybe<Scalars["String"]>; value?: Maybe<Scalars["String"]> }

delete key/value pair or string element. key/value pairs are matched based on their key value

Type declaration

Kv_Store_Inc_Input

Kv_Store_Inc_Input: { created_by?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]>; scope_object_id?: Maybe<Scalars["Int"]> }

input type for incrementing numeric columns in table "kv_store"

Type declaration

Kv_Store_Insert_Input

Kv_Store_Insert_Input: { created_at?: Maybe<Scalars["timestamptz"]>; created_by?: Maybe<Scalars["Int"]>; developer?: Maybe<Developers_Obj_Rel_Insert_Input>; key?: Maybe<Scalars["String"]>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]>; scope?: Maybe<Scalars["String"]>; scope_object_id?: Maybe<Scalars["Int"]>; updated_at?: Maybe<Scalars["timestamptz"]>; value?: Maybe<Scalars["jsonb"]> }

input type for inserting data into table "kv_store"

Type declaration

Kv_Store_Max_Fields

Kv_Store_Max_Fields: { __typename?: "kv_store_max_fields"; created_at?: Maybe<Scalars["timestamptz"]>; created_by?: Maybe<Scalars["Int"]>; key?: Maybe<Scalars["String"]>; object_id?: Maybe<Scalars["Int"]>; scope?: Maybe<Scalars["String"]>; scope_object_id?: Maybe<Scalars["Int"]>; updated_at?: Maybe<Scalars["timestamptz"]> }

aggregate max on columns

Type declaration

Kv_Store_Max_Order_By

Kv_Store_Max_Order_By: { created_at?: Maybe<Order_By>; created_by?: Maybe<Order_By>; key?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By>; updated_at?: Maybe<Order_By> }

order by max() on columns of table "kv_store"

Type declaration

Kv_Store_Min_Fields

Kv_Store_Min_Fields: { __typename?: "kv_store_min_fields"; created_at?: Maybe<Scalars["timestamptz"]>; created_by?: Maybe<Scalars["Int"]>; key?: Maybe<Scalars["String"]>; object_id?: Maybe<Scalars["Int"]>; scope?: Maybe<Scalars["String"]>; scope_object_id?: Maybe<Scalars["Int"]>; updated_at?: Maybe<Scalars["timestamptz"]> }

aggregate min on columns

Type declaration

Kv_Store_Min_Order_By

Kv_Store_Min_Order_By: { created_at?: Maybe<Order_By>; created_by?: Maybe<Order_By>; key?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By>; updated_at?: Maybe<Order_By> }

order by min() on columns of table "kv_store"

Type declaration

Kv_Store_Mutation_Response

Kv_Store_Mutation_Response: { __typename?: "kv_store_mutation_response"; affected_rows: Scalars["Int"]; returning: Kv_Store[] }

response of any mutation on the table "kv_store"

Type declaration

  • Optional __typename?: "kv_store_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Kv_Store[]

    data from the rows affected by the mutation

Kv_Store_On_Conflict

Kv_Store_On_Conflict: { constraint: Kv_Store_Constraint; update_columns: Kv_Store_Update_Column[]; where?: Maybe<Kv_Store_Bool_Exp> }

on conflict condition type for table "kv_store"

Type declaration

Kv_Store_Order_By

Kv_Store_Order_By: { created_at?: Maybe<Order_By>; created_by?: Maybe<Order_By>; developer?: Maybe<Developers_Order_By>; key?: Maybe<Order_By>; metadata?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By>; updated_at?: Maybe<Order_By>; value?: Maybe<Order_By> }

Ordering options when selecting data from "kv_store".

Type declaration

Kv_Store_Pk_Columns_Input

Kv_Store_Pk_Columns_Input: { key: Scalars["String"]; scope: Scalars["String"]; scope_object_id: Scalars["Int"] }

primary key columns input for table: kv_store

Type declaration

Kv_Store_Prepend_Input

Kv_Store_Prepend_Input: { metadata?: Maybe<Scalars["jsonb"]>; value?: Maybe<Scalars["jsonb"]> }

prepend existing jsonb value of filtered columns with new jsonb value

Type declaration

Kv_Store_Set_Input

Kv_Store_Set_Input: { created_at?: Maybe<Scalars["timestamptz"]>; created_by?: Maybe<Scalars["Int"]>; key?: Maybe<Scalars["String"]>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]>; scope?: Maybe<Scalars["String"]>; scope_object_id?: Maybe<Scalars["Int"]>; updated_at?: Maybe<Scalars["timestamptz"]>; value?: Maybe<Scalars["jsonb"]> }

input type for updating data in table "kv_store"

Type declaration

Kv_Store_Stddev_Fields

Kv_Store_Stddev_Fields: { __typename?: "kv_store_stddev_fields"; created_by?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]>; scope_object_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "kv_store_stddev_fields"
  • Optional created_by?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>
  • Optional scope_object_id?: Maybe<Scalars["Float"]>

Kv_Store_Stddev_Order_By

Kv_Store_Stddev_Order_By: { created_by?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By> }

order by stddev() on columns of table "kv_store"

Type declaration

Kv_Store_Stddev_Pop_Fields

Kv_Store_Stddev_Pop_Fields: { __typename?: "kv_store_stddev_pop_fields"; created_by?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]>; scope_object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "kv_store_stddev_pop_fields"
  • Optional created_by?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>
  • Optional scope_object_id?: Maybe<Scalars["Float"]>

Kv_Store_Stddev_Pop_Order_By

Kv_Store_Stddev_Pop_Order_By: { created_by?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By> }

order by stddev_pop() on columns of table "kv_store"

Type declaration

Kv_Store_Stddev_Samp_Fields

Kv_Store_Stddev_Samp_Fields: { __typename?: "kv_store_stddev_samp_fields"; created_by?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]>; scope_object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "kv_store_stddev_samp_fields"
  • Optional created_by?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>
  • Optional scope_object_id?: Maybe<Scalars["Float"]>

Kv_Store_Stddev_Samp_Order_By

Kv_Store_Stddev_Samp_Order_By: { created_by?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By> }

order by stddev_samp() on columns of table "kv_store"

Type declaration

Kv_Store_Sum_Fields

Kv_Store_Sum_Fields: { __typename?: "kv_store_sum_fields"; created_by?: Maybe<Scalars["Int"]>; object_id?: Maybe<Scalars["Int"]>; scope_object_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "kv_store_sum_fields"
  • Optional created_by?: Maybe<Scalars["Int"]>
  • Optional object_id?: Maybe<Scalars["Int"]>
  • Optional scope_object_id?: Maybe<Scalars["Int"]>

Kv_Store_Sum_Order_By

Kv_Store_Sum_Order_By: { created_by?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By> }

order by sum() on columns of table "kv_store"

Type declaration

Kv_Store_Var_Pop_Fields

Kv_Store_Var_Pop_Fields: { __typename?: "kv_store_var_pop_fields"; created_by?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]>; scope_object_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "kv_store_var_pop_fields"
  • Optional created_by?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>
  • Optional scope_object_id?: Maybe<Scalars["Float"]>

Kv_Store_Var_Pop_Order_By

Kv_Store_Var_Pop_Order_By: { created_by?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By> }

order by var_pop() on columns of table "kv_store"

Type declaration

Kv_Store_Var_Samp_Fields

Kv_Store_Var_Samp_Fields: { __typename?: "kv_store_var_samp_fields"; created_by?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]>; scope_object_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "kv_store_var_samp_fields"
  • Optional created_by?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>
  • Optional scope_object_id?: Maybe<Scalars["Float"]>

Kv_Store_Var_Samp_Order_By

Kv_Store_Var_Samp_Order_By: { created_by?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By> }

order by var_samp() on columns of table "kv_store"

Type declaration

Kv_Store_Variance_Fields

Kv_Store_Variance_Fields: { __typename?: "kv_store_variance_fields"; created_by?: Maybe<Scalars["Float"]>; object_id?: Maybe<Scalars["Float"]>; scope_object_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "kv_store_variance_fields"
  • Optional created_by?: Maybe<Scalars["Float"]>
  • Optional object_id?: Maybe<Scalars["Float"]>
  • Optional scope_object_id?: Maybe<Scalars["Float"]>

Kv_Store_Variance_Order_By

Kv_Store_Variance_Order_By: { created_by?: Maybe<Order_By>; object_id?: Maybe<Order_By>; scope_object_id?: Maybe<Order_By> }

order by variance() on columns of table "kv_store"

Type declaration

Last_Utterance

Last_Utterance: { __typename?: "last_utterance"; conversation?: Maybe<Conversations>; conversation_id?: Maybe<Scalars["Int"]>; interval?: Maybe<Scalars["timestamptz"]>; speaker_type?: Maybe<Scalars["String"]>; updated_at?: Maybe<Scalars["timestamptz"]>; utterance?: Maybe<Scalars["String"]> }

columns and relationships of "last_utterance"

Type declaration

Last_Utterance_Aggregate

Last_Utterance_Aggregate: { __typename?: "last_utterance_aggregate"; aggregate?: Maybe<Last_Utterance_Aggregate_Fields>; nodes: Last_Utterance[] }

aggregated selection of "last_utterance"

Type declaration

Last_Utterance_Aggregate_Fields

Last_Utterance_Aggregate_Fields: { __typename?: "last_utterance_aggregate_fields"; avg?: Maybe<Last_Utterance_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<Last_Utterance_Max_Fields>; min?: Maybe<Last_Utterance_Min_Fields>; stddev?: Maybe<Last_Utterance_Stddev_Fields>; stddev_pop?: Maybe<Last_Utterance_Stddev_Pop_Fields>; stddev_samp?: Maybe<Last_Utterance_Stddev_Samp_Fields>; sum?: Maybe<Last_Utterance_Sum_Fields>; var_pop?: Maybe<Last_Utterance_Var_Pop_Fields>; var_samp?: Maybe<Last_Utterance_Var_Samp_Fields>; variance?: Maybe<Last_Utterance_Variance_Fields> }

aggregate fields of "last_utterance"

Type declaration

Last_Utterance_Aggregate_FieldsCountArgs

Last_Utterance_Aggregate_FieldsCountArgs: { columns?: Maybe<Last_Utterance_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "last_utterance"

Type declaration

Last_Utterance_Avg_Fields

Last_Utterance_Avg_Fields: { __typename?: "last_utterance_avg_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "last_utterance_avg_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

Last_Utterance_Bool_Exp

Last_Utterance_Bool_Exp: { _and?: Maybe<Last_Utterance_Bool_Exp[]>; _not?: Maybe<Last_Utterance_Bool_Exp>; _or?: Maybe<Last_Utterance_Bool_Exp[]>; conversation?: Maybe<Conversations_Bool_Exp>; conversation_id?: Maybe<Int_Comparison_Exp>; interval?: Maybe<Timestamptz_Comparison_Exp>; speaker_type?: Maybe<String_Comparison_Exp>; updated_at?: Maybe<Timestamptz_Comparison_Exp>; utterance?: Maybe<String_Comparison_Exp> }

Boolean expression to filter rows from the table "last_utterance". All fields are combined with a logical 'AND'.

Type declaration

Last_Utterance_Max_Fields

Last_Utterance_Max_Fields: { __typename?: "last_utterance_max_fields"; conversation_id?: Maybe<Scalars["Int"]>; interval?: Maybe<Scalars["timestamptz"]>; speaker_type?: Maybe<Scalars["String"]>; updated_at?: Maybe<Scalars["timestamptz"]>; utterance?: Maybe<Scalars["String"]> }

aggregate max on columns

Type declaration

Last_Utterance_Min_Fields

Last_Utterance_Min_Fields: { __typename?: "last_utterance_min_fields"; conversation_id?: Maybe<Scalars["Int"]>; interval?: Maybe<Scalars["timestamptz"]>; speaker_type?: Maybe<Scalars["String"]>; updated_at?: Maybe<Scalars["timestamptz"]>; utterance?: Maybe<Scalars["String"]> }

aggregate min on columns

Type declaration

Last_Utterance_Order_By

Last_Utterance_Order_By: { conversation?: Maybe<Conversations_Order_By>; conversation_id?: Maybe<Order_By>; interval?: Maybe<Order_By>; speaker_type?: Maybe<Order_By>; updated_at?: Maybe<Order_By>; utterance?: Maybe<Order_By> }

Ordering options when selecting data from "last_utterance".

Type declaration

Last_Utterance_Stddev_Fields

Last_Utterance_Stddev_Fields: { __typename?: "last_utterance_stddev_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "last_utterance_stddev_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

Last_Utterance_Stddev_Pop_Fields

Last_Utterance_Stddev_Pop_Fields: { __typename?: "last_utterance_stddev_pop_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "last_utterance_stddev_pop_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

Last_Utterance_Stddev_Samp_Fields

Last_Utterance_Stddev_Samp_Fields: { __typename?: "last_utterance_stddev_samp_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "last_utterance_stddev_samp_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

Last_Utterance_Sum_Fields

Last_Utterance_Sum_Fields: { __typename?: "last_utterance_sum_fields"; conversation_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "last_utterance_sum_fields"
  • Optional conversation_id?: Maybe<Scalars["Int"]>

Last_Utterance_Var_Pop_Fields

Last_Utterance_Var_Pop_Fields: { __typename?: "last_utterance_var_pop_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "last_utterance_var_pop_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

Last_Utterance_Var_Samp_Fields

Last_Utterance_Var_Samp_Fields: { __typename?: "last_utterance_var_samp_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "last_utterance_var_samp_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

Last_Utterance_Variance_Fields

Last_Utterance_Variance_Fields: { __typename?: "last_utterance_variance_fields"; conversation_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "last_utterance_variance_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>

MakeMaybe

MakeMaybe<T, K>: Omit<T, K> & {[ SubKey in K]: Maybe<T[SubKey]> }

Type parameters

  • T

  • K: keyof T

MakeOptional

MakeOptional<T, K>: Omit<T, K> & {[ SubKey in K]: Maybe<T[SubKey]> }

Type parameters

  • T

  • K: keyof T

MatchIntentOutput

MatchIntentOutput: { __typename?: "MatchIntentOutput"; result?: Maybe<Maybe<PhraseMatch>[]>; warnings?: Maybe<Maybe<Scalars["String"]>[]> }

Intent matching output

Type declaration

  • Optional __typename?: "MatchIntentOutput"
  • Optional result?: Maybe<Maybe<PhraseMatch>[]>

    A list of matches found

  • Optional warnings?: Maybe<Maybe<Scalars["String"]>[]>

    A list of processing errors if any

MatchIntentQuery

MatchIntentQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "MatchIntentOutput" } & { matches?: Maybe<Maybe<{ __typename?: "PhraseMatch" } & Pick<PhraseMatch, "matched_intent" | "similarity"> & { slots?: Maybe<Maybe<{ __typename?: "WordMatch" } & Pick<WordMatch, "slot" | "match_type"> & { confidence: WordMatch["similarity"]; value: WordMatch["extracted_word"] }>[]> }>[]> }> }

MatchIntentQueryVariables

MatchIntentQueryVariables: Exact<{ input: Scalars["String"]; intents: Scalars["String"][] | Scalars["String"] }>

Maybe

Maybe<T>: T | null

Type parameters

  • T

MeasureSimilarityQuery

MeasureSimilarityQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "SentenceSimilarityScores" } & { scores?: Maybe<Maybe<{ __typename?: "PairSimilarity" } & Pick<PairSimilarity, "score" | "candidate">>[]> }> }

MeasureSimilarityQueryVariables

MeasureSimilarityQueryVariables: Exact<{ candidates: Scalars["String"][] | Scalars["String"]; input: Scalars["String"] }>

Mutation_Root

Mutation_Root: { __typename?: "mutation_root"; delete_apps?: Maybe<Apps_Mutation_Response>; delete_atomic_data?: Maybe<Atomic_Data_Mutation_Response>; delete_audit_logged_actions?: Maybe<Audit_Logged_Actions_Mutation_Response>; delete_audit_logged_actions_by_pk?: Maybe<Audit_Logged_Actions>; delete_conceptnet_data?: Maybe<Conceptnet_Data_Mutation_Response>; delete_conversations?: Maybe<Conversations_Mutation_Response>; delete_developers?: Maybe<Developers_Mutation_Response>; delete_end_user_conversations?: Maybe<End_User_Conversations_Mutation_Response>; delete_end_user_conversations_by_pk?: Maybe<End_User_Conversations>; delete_end_users?: Maybe<End_Users_Mutation_Response>; delete_events?: Maybe<Events_Mutation_Response>; delete_kv_scope_enum?: Maybe<Kv_Scope_Enum_Mutation_Response>; delete_kv_scope_enum_by_pk?: Maybe<Kv_Scope_Enum>; delete_kv_store?: Maybe<Kv_Store_Mutation_Response>; delete_kv_store_by_pk?: Maybe<Kv_Store>; delete_objects?: Maybe<Objects_Mutation_Response>; delete_objects_by_pk?: Maybe<Objects>; delete_speaker_type_enum?: Maybe<Speaker_Type_Enum_Mutation_Response>; delete_speaker_type_enum_by_pk?: Maybe<Speaker_Type_Enum>; delete_utterances?: Maybe<Utterances_Mutation_Response>; insert_apps?: Maybe<Apps_Mutation_Response>; insert_apps_one?: Maybe<Apps>; insert_atomic_data?: Maybe<Atomic_Data_Mutation_Response>; insert_atomic_data_one?: Maybe<Atomic_Data>; insert_audit_logged_actions?: Maybe<Audit_Logged_Actions_Mutation_Response>; insert_audit_logged_actions_one?: Maybe<Audit_Logged_Actions>; insert_conceptnet_data?: Maybe<Conceptnet_Data_Mutation_Response>; insert_conceptnet_data_one?: Maybe<Conceptnet_Data>; insert_conversations?: Maybe<Conversations_Mutation_Response>; insert_conversations_one?: Maybe<Conversations>; insert_developers?: Maybe<Developers_Mutation_Response>; insert_developers_one?: Maybe<Developers>; insert_end_user_conversations?: Maybe<End_User_Conversations_Mutation_Response>; insert_end_user_conversations_one?: Maybe<End_User_Conversations>; insert_end_users?: Maybe<End_Users_Mutation_Response>; insert_end_users_one?: Maybe<End_Users>; insert_events?: Maybe<Events_Mutation_Response>; insert_events_one?: Maybe<Events>; insert_kv_scope_enum?: Maybe<Kv_Scope_Enum_Mutation_Response>; insert_kv_scope_enum_one?: Maybe<Kv_Scope_Enum>; insert_kv_store?: Maybe<Kv_Store_Mutation_Response>; insert_kv_store_one?: Maybe<Kv_Store>; insert_objects?: Maybe<Objects_Mutation_Response>; insert_objects_one?: Maybe<Objects>; insert_speaker_type_enum?: Maybe<Speaker_Type_Enum_Mutation_Response>; insert_speaker_type_enum_one?: Maybe<Speaker_Type_Enum>; insert_utterances?: Maybe<Utterances_Mutation_Response>; insert_utterances_one?: Maybe<Utterances>; update_apps?: Maybe<Apps_Mutation_Response>; update_atomic_data?: Maybe<Atomic_Data_Mutation_Response>; update_audit_logged_actions?: Maybe<Audit_Logged_Actions_Mutation_Response>; update_audit_logged_actions_by_pk?: Maybe<Audit_Logged_Actions>; update_conceptnet_data?: Maybe<Conceptnet_Data_Mutation_Response>; update_conversations?: Maybe<Conversations_Mutation_Response>; update_developers?: Maybe<Developers_Mutation_Response>; update_end_user_conversations?: Maybe<End_User_Conversations_Mutation_Response>; update_end_user_conversations_by_pk?: Maybe<End_User_Conversations>; update_end_users?: Maybe<End_Users_Mutation_Response>; update_events?: Maybe<Events_Mutation_Response>; update_kv_scope_enum?: Maybe<Kv_Scope_Enum_Mutation_Response>; update_kv_scope_enum_by_pk?: Maybe<Kv_Scope_Enum>; update_kv_store?: Maybe<Kv_Store_Mutation_Response>; update_kv_store_by_pk?: Maybe<Kv_Store>; update_objects?: Maybe<Objects_Mutation_Response>; update_objects_by_pk?: Maybe<Objects>; update_speaker_type_enum?: Maybe<Speaker_Type_Enum_Mutation_Response>; update_speaker_type_enum_by_pk?: Maybe<Speaker_Type_Enum>; update_utterances?: Maybe<Utterances_Mutation_Response> }

mutation root

Type declaration

Mutation_RootDelete_AppsArgs

Mutation_RootDelete_AppsArgs: { where: Apps_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_Atomic_DataArgs

Mutation_RootDelete_Atomic_DataArgs: { where: Atomic_Data_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_Audit_Logged_ActionsArgs

Mutation_RootDelete_Audit_Logged_ActionsArgs: { where: Audit_Logged_Actions_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_Audit_Logged_Actions_By_PkArgs

Mutation_RootDelete_Audit_Logged_Actions_By_PkArgs: { action_tstamp_stm: Scalars["timestamptz"]; event_id: Scalars["bigint"] }

mutation root

Type declaration

  • action_tstamp_stm: Scalars["timestamptz"]
  • event_id: Scalars["bigint"]

Mutation_RootDelete_Conceptnet_DataArgs

Mutation_RootDelete_Conceptnet_DataArgs: { where: Conceptnet_Data_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_ConversationsArgs

Mutation_RootDelete_ConversationsArgs: { where: Conversations_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_DevelopersArgs

Mutation_RootDelete_DevelopersArgs: { where: Developers_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_End_User_ConversationsArgs

Mutation_RootDelete_End_User_ConversationsArgs: { where: End_User_Conversations_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_End_User_Conversations_By_PkArgs

Mutation_RootDelete_End_User_Conversations_By_PkArgs: { conversation_id: Scalars["Int"]; end_user_id: Scalars["Int"] }

mutation root

Type declaration

Mutation_RootDelete_End_UsersArgs

Mutation_RootDelete_End_UsersArgs: { where: End_Users_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_EventsArgs

Mutation_RootDelete_EventsArgs: { where: Events_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_Kv_Scope_EnumArgs

Mutation_RootDelete_Kv_Scope_EnumArgs: { where: Kv_Scope_Enum_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_Kv_Scope_Enum_By_PkArgs

Mutation_RootDelete_Kv_Scope_Enum_By_PkArgs: { value: Scalars["String"] }

mutation root

Type declaration

Mutation_RootDelete_Kv_StoreArgs

Mutation_RootDelete_Kv_StoreArgs: { where: Kv_Store_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_Kv_Store_By_PkArgs

Mutation_RootDelete_Kv_Store_By_PkArgs: { key: Scalars["String"]; scope: Scalars["String"]; scope_object_id: Scalars["Int"] }

mutation root

Type declaration

Mutation_RootDelete_ObjectsArgs

Mutation_RootDelete_ObjectsArgs: { where: Objects_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_Objects_By_PkArgs

Mutation_RootDelete_Objects_By_PkArgs: { object_id: Scalars["Int"] }

mutation root

Type declaration

Mutation_RootDelete_Speaker_Type_EnumArgs

Mutation_RootDelete_Speaker_Type_EnumArgs: { where: Speaker_Type_Enum_Bool_Exp }

mutation root

Type declaration

Mutation_RootDelete_Speaker_Type_Enum_By_PkArgs

Mutation_RootDelete_Speaker_Type_Enum_By_PkArgs: { value: Scalars["String"] }

mutation root

Type declaration

Mutation_RootDelete_UtterancesArgs

Mutation_RootDelete_UtterancesArgs: { where: Utterances_Bool_Exp }

mutation root

Type declaration

Mutation_RootInsert_AppsArgs

Mutation_RootInsert_AppsArgs: { objects: Apps_Insert_Input[]; on_conflict?: Maybe<Apps_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Apps_OneArgs

Mutation_RootInsert_Apps_OneArgs: { object: Apps_Insert_Input; on_conflict?: Maybe<Apps_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Atomic_DataArgs

Mutation_RootInsert_Atomic_DataArgs: { objects: Atomic_Data_Insert_Input[] }

mutation root

Type declaration

Mutation_RootInsert_Atomic_Data_OneArgs

Mutation_RootInsert_Atomic_Data_OneArgs: { object: Atomic_Data_Insert_Input }

mutation root

Type declaration

Mutation_RootInsert_Audit_Logged_ActionsArgs

Mutation_RootInsert_Audit_Logged_ActionsArgs: { objects: Audit_Logged_Actions_Insert_Input[]; on_conflict?: Maybe<Audit_Logged_Actions_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Audit_Logged_Actions_OneArgs

Mutation_RootInsert_Audit_Logged_Actions_OneArgs: { object: Audit_Logged_Actions_Insert_Input; on_conflict?: Maybe<Audit_Logged_Actions_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Conceptnet_DataArgs

Mutation_RootInsert_Conceptnet_DataArgs: { objects: Conceptnet_Data_Insert_Input[]; on_conflict?: Maybe<Conceptnet_Data_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Conceptnet_Data_OneArgs

Mutation_RootInsert_Conceptnet_Data_OneArgs: { object: Conceptnet_Data_Insert_Input; on_conflict?: Maybe<Conceptnet_Data_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_ConversationsArgs

Mutation_RootInsert_ConversationsArgs: { objects: Conversations_Insert_Input[]; on_conflict?: Maybe<Conversations_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Conversations_OneArgs

Mutation_RootInsert_Conversations_OneArgs: { object: Conversations_Insert_Input; on_conflict?: Maybe<Conversations_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_DevelopersArgs

Mutation_RootInsert_DevelopersArgs: { objects: Developers_Insert_Input[]; on_conflict?: Maybe<Developers_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Developers_OneArgs

Mutation_RootInsert_Developers_OneArgs: { object: Developers_Insert_Input; on_conflict?: Maybe<Developers_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_End_User_ConversationsArgs

Mutation_RootInsert_End_User_ConversationsArgs: { objects: End_User_Conversations_Insert_Input[]; on_conflict?: Maybe<End_User_Conversations_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_End_User_Conversations_OneArgs

Mutation_RootInsert_End_User_Conversations_OneArgs: { object: End_User_Conversations_Insert_Input; on_conflict?: Maybe<End_User_Conversations_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_End_UsersArgs

Mutation_RootInsert_End_UsersArgs: { objects: End_Users_Insert_Input[]; on_conflict?: Maybe<End_Users_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_End_Users_OneArgs

Mutation_RootInsert_End_Users_OneArgs: { object: End_Users_Insert_Input; on_conflict?: Maybe<End_Users_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_EventsArgs

Mutation_RootInsert_EventsArgs: { objects: Events_Insert_Input[] }

mutation root

Type declaration

Mutation_RootInsert_Events_OneArgs

Mutation_RootInsert_Events_OneArgs: { object: Events_Insert_Input }

mutation root

Type declaration

Mutation_RootInsert_Kv_Scope_EnumArgs

Mutation_RootInsert_Kv_Scope_EnumArgs: { objects: Kv_Scope_Enum_Insert_Input[]; on_conflict?: Maybe<Kv_Scope_Enum_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Kv_Scope_Enum_OneArgs

Mutation_RootInsert_Kv_Scope_Enum_OneArgs: { object: Kv_Scope_Enum_Insert_Input; on_conflict?: Maybe<Kv_Scope_Enum_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Kv_StoreArgs

Mutation_RootInsert_Kv_StoreArgs: { objects: Kv_Store_Insert_Input[]; on_conflict?: Maybe<Kv_Store_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Kv_Store_OneArgs

Mutation_RootInsert_Kv_Store_OneArgs: { object: Kv_Store_Insert_Input; on_conflict?: Maybe<Kv_Store_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_ObjectsArgs

Mutation_RootInsert_ObjectsArgs: { objects: Objects_Insert_Input[]; on_conflict?: Maybe<Objects_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Objects_OneArgs

Mutation_RootInsert_Objects_OneArgs: { object: Objects_Insert_Input; on_conflict?: Maybe<Objects_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Speaker_Type_EnumArgs

Mutation_RootInsert_Speaker_Type_EnumArgs: { objects: Speaker_Type_Enum_Insert_Input[]; on_conflict?: Maybe<Speaker_Type_Enum_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_Speaker_Type_Enum_OneArgs

Mutation_RootInsert_Speaker_Type_Enum_OneArgs: { object: Speaker_Type_Enum_Insert_Input; on_conflict?: Maybe<Speaker_Type_Enum_On_Conflict> }

mutation root

Type declaration

Mutation_RootInsert_UtterancesArgs

Mutation_RootInsert_UtterancesArgs: { objects: Utterances_Insert_Input[] }

mutation root

Type declaration

Mutation_RootInsert_Utterances_OneArgs

Mutation_RootInsert_Utterances_OneArgs: { object: Utterances_Insert_Input }

mutation root

Type declaration

Mutation_RootUpdate_AppsArgs

Mutation_RootUpdate_AppsArgs: { _append?: Maybe<Apps_Append_Input>; _delete_at_path?: Maybe<Apps_Delete_At_Path_Input>; _delete_elem?: Maybe<Apps_Delete_Elem_Input>; _delete_key?: Maybe<Apps_Delete_Key_Input>; _inc?: Maybe<Apps_Inc_Input>; _prepend?: Maybe<Apps_Prepend_Input>; _set?: Maybe<Apps_Set_Input>; where: Apps_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_Atomic_DataArgs

Mutation_RootUpdate_Atomic_DataArgs: { _set?: Maybe<Atomic_Data_Set_Input>; where: Atomic_Data_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_Audit_Logged_ActionsArgs

mutation root

Mutation_RootUpdate_Audit_Logged_Actions_By_PkArgs

mutation root

Mutation_RootUpdate_Conceptnet_DataArgs

Mutation_RootUpdate_Conceptnet_DataArgs: { _inc?: Maybe<Conceptnet_Data_Inc_Input>; _set?: Maybe<Conceptnet_Data_Set_Input>; where: Conceptnet_Data_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_ConversationsArgs

mutation root

Type declaration

Mutation_RootUpdate_DevelopersArgs

Mutation_RootUpdate_DevelopersArgs: { _append?: Maybe<Developers_Append_Input>; _delete_at_path?: Maybe<Developers_Delete_At_Path_Input>; _delete_elem?: Maybe<Developers_Delete_Elem_Input>; _delete_key?: Maybe<Developers_Delete_Key_Input>; _inc?: Maybe<Developers_Inc_Input>; _prepend?: Maybe<Developers_Prepend_Input>; _set?: Maybe<Developers_Set_Input>; where: Developers_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_End_User_ConversationsArgs

Mutation_RootUpdate_End_User_ConversationsArgs: { _inc?: Maybe<End_User_Conversations_Inc_Input>; _set?: Maybe<End_User_Conversations_Set_Input>; where: End_User_Conversations_Bool_Exp }

mutation root

Mutation_RootUpdate_End_User_Conversations_By_PkArgs

Mutation_RootUpdate_End_User_Conversations_By_PkArgs: { _inc?: Maybe<End_User_Conversations_Inc_Input>; _set?: Maybe<End_User_Conversations_Set_Input>; pk_columns: End_User_Conversations_Pk_Columns_Input }

mutation root

Mutation_RootUpdate_End_UsersArgs

Mutation_RootUpdate_End_UsersArgs: { _append?: Maybe<End_Users_Append_Input>; _delete_at_path?: Maybe<End_Users_Delete_At_Path_Input>; _delete_elem?: Maybe<End_Users_Delete_Elem_Input>; _delete_key?: Maybe<End_Users_Delete_Key_Input>; _inc?: Maybe<End_Users_Inc_Input>; _prepend?: Maybe<End_Users_Prepend_Input>; _set?: Maybe<End_Users_Set_Input>; where: End_Users_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_EventsArgs

Mutation_RootUpdate_EventsArgs: { _append?: Maybe<Events_Append_Input>; _delete_at_path?: Maybe<Events_Delete_At_Path_Input>; _delete_elem?: Maybe<Events_Delete_Elem_Input>; _delete_key?: Maybe<Events_Delete_Key_Input>; _prepend?: Maybe<Events_Prepend_Input>; _set?: Maybe<Events_Set_Input>; where: Events_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_Kv_Scope_EnumArgs

Mutation_RootUpdate_Kv_Scope_EnumArgs: { _set?: Maybe<Kv_Scope_Enum_Set_Input>; where: Kv_Scope_Enum_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_Kv_Scope_Enum_By_PkArgs

Mutation_RootUpdate_Kv_Scope_Enum_By_PkArgs: { _set?: Maybe<Kv_Scope_Enum_Set_Input>; pk_columns: Kv_Scope_Enum_Pk_Columns_Input }

mutation root

Type declaration

Mutation_RootUpdate_Kv_StoreArgs

Mutation_RootUpdate_Kv_StoreArgs: { _append?: Maybe<Kv_Store_Append_Input>; _delete_at_path?: Maybe<Kv_Store_Delete_At_Path_Input>; _delete_elem?: Maybe<Kv_Store_Delete_Elem_Input>; _delete_key?: Maybe<Kv_Store_Delete_Key_Input>; _inc?: Maybe<Kv_Store_Inc_Input>; _prepend?: Maybe<Kv_Store_Prepend_Input>; _set?: Maybe<Kv_Store_Set_Input>; where: Kv_Store_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_Kv_Store_By_PkArgs

Mutation_RootUpdate_Kv_Store_By_PkArgs: { _append?: Maybe<Kv_Store_Append_Input>; _delete_at_path?: Maybe<Kv_Store_Delete_At_Path_Input>; _delete_elem?: Maybe<Kv_Store_Delete_Elem_Input>; _delete_key?: Maybe<Kv_Store_Delete_Key_Input>; _inc?: Maybe<Kv_Store_Inc_Input>; _prepend?: Maybe<Kv_Store_Prepend_Input>; _set?: Maybe<Kv_Store_Set_Input>; pk_columns: Kv_Store_Pk_Columns_Input }

mutation root

Type declaration

Mutation_RootUpdate_ObjectsArgs

Mutation_RootUpdate_ObjectsArgs: { _append?: Maybe<Objects_Append_Input>; _delete_at_path?: Maybe<Objects_Delete_At_Path_Input>; _delete_elem?: Maybe<Objects_Delete_Elem_Input>; _delete_key?: Maybe<Objects_Delete_Key_Input>; _inc?: Maybe<Objects_Inc_Input>; _prepend?: Maybe<Objects_Prepend_Input>; _set?: Maybe<Objects_Set_Input>; where: Objects_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_Objects_By_PkArgs

Mutation_RootUpdate_Objects_By_PkArgs: { _append?: Maybe<Objects_Append_Input>; _delete_at_path?: Maybe<Objects_Delete_At_Path_Input>; _delete_elem?: Maybe<Objects_Delete_Elem_Input>; _delete_key?: Maybe<Objects_Delete_Key_Input>; _inc?: Maybe<Objects_Inc_Input>; _prepend?: Maybe<Objects_Prepend_Input>; _set?: Maybe<Objects_Set_Input>; pk_columns: Objects_Pk_Columns_Input }

mutation root

Type declaration

Mutation_RootUpdate_Speaker_Type_EnumArgs

Mutation_RootUpdate_Speaker_Type_EnumArgs: { _set?: Maybe<Speaker_Type_Enum_Set_Input>; where: Speaker_Type_Enum_Bool_Exp }

mutation root

Type declaration

Mutation_RootUpdate_Speaker_Type_Enum_By_PkArgs

Mutation_RootUpdate_Speaker_Type_Enum_By_PkArgs: { _set?: Maybe<Speaker_Type_Enum_Set_Input>; pk_columns: Speaker_Type_Enum_Pk_Columns_Input }

mutation root

Type declaration

Mutation_RootUpdate_UtterancesArgs

Mutation_RootUpdate_UtterancesArgs: { _inc?: Maybe<Utterances_Inc_Input>; _set?: Maybe<Utterances_Set_Input>; where: Utterances_Bool_Exp }

mutation root

Type declaration

NlpDoc

NlpDoc: Container & { __typename?: "NlpDoc"; cats?: Maybe<Maybe<Cat>[]>; ents?: Maybe<Maybe<Span>[]>; extension?: Maybe<DocExtension>; has_vector?: Maybe<Scalars["Boolean"]>; id?: Maybe<Scalars["Int"]>; noun_chunks?: Maybe<Maybe<Span>[]>; sentiment?: Maybe<Scalars["Float"]>; sents?: Maybe<Maybe<Span>[]>; text?: Maybe<Scalars["String"]>; text_with_ws?: Maybe<Scalars["String"]>; tokens?: Maybe<Maybe<Token>[]>; vector?: Maybe<Maybe<Scalars["Float"]>[]>; vector_norm?: Maybe<Scalars["Float"]> }

A container for accessing linguistic annotations. Access sentences and named entities.

NluResult

NluResult: Container & { __typename?: "NLUResult"; entities?: Maybe<Maybe<NluSpan>[]>; has_vector?: Maybe<Scalars["Boolean"]>; noun_chunks?: Maybe<Maybe<NluSpan>[]>; sentences?: Maybe<Maybe<NluSpan>[]>; text?: Maybe<Scalars["String"]>; text_with_ws?: Maybe<Scalars["String"]>; tokens?: Maybe<Maybe<NluToken>[]>; vector?: Maybe<Maybe<Scalars["Float"]>[]>; vector_norm?: Maybe<Scalars["Float"]> }

A container for accessing linguistic annotations. Access sentences and named entities.

NluSpan

NluSpan: Container & { __typename?: "NLUSpan"; entities?: Maybe<Maybe<NluSpan>[]>; has_vector?: Maybe<Scalars["Boolean"]>; lemma?: Maybe<Scalars["String"]>; subtree?: Maybe<Maybe<NluToken>[]>; text?: Maybe<Scalars["String"]>; text_with_ws?: Maybe<Scalars["String"]>; tokens?: Maybe<Maybe<NluToken>[]>; vector?: Maybe<Maybe<Scalars["Float"]>[]>; vector_norm?: Maybe<Scalars["Float"]> }

A slice from a Doc object

NluToken

NluToken: Container & { __typename?: "NLUToken"; dependency?: Maybe<Scalars["String"]>; entity_type?: Maybe<Scalars["String"]>; has_vector?: Maybe<Scalars["Boolean"]>; is_alpha?: Maybe<Scalars["Boolean"]>; is_ascii?: Maybe<Scalars["Boolean"]>; is_bracket?: Maybe<Scalars["Boolean"]>; is_currency?: Maybe<Scalars["Boolean"]>; is_digit?: Maybe<Scalars["Boolean"]>; is_left_punct?: Maybe<Scalars["Boolean"]>; is_lower?: Maybe<Scalars["Boolean"]>; is_oov?: Maybe<Scalars["Boolean"]>; is_punct?: Maybe<Scalars["Boolean"]>; is_quote?: Maybe<Scalars["Boolean"]>; is_right_punct?: Maybe<Scalars["Boolean"]>; is_sent_start?: Maybe<Scalars["Boolean"]>; is_space?: Maybe<Scalars["Boolean"]>; is_stop?: Maybe<Scalars["Boolean"]>; is_title?: Maybe<Scalars["Boolean"]>; is_upper?: Maybe<Scalars["Boolean"]>; lemma?: Maybe<Scalars["String"]>; like_email?: Maybe<Scalars["Boolean"]>; like_num?: Maybe<Scalars["Boolean"]>; like_url?: Maybe<Scalars["Boolean"]>; log_probability?: Maybe<Scalars["Float"]>; normalized?: Maybe<Scalars["String"]>; part_of_speech?: Maybe<Scalars["String"]>; subtree?: Maybe<Maybe<NluToken>[]>; tag?: Maybe<Scalars["String"]>; text?: Maybe<Scalars["String"]>; text_with_ws?: Maybe<Scalars["String"]>; vector?: Maybe<Maybe<Scalars["Float"]>[]>; vector_norm?: Maybe<Scalars["Float"]> }

An individual token — i.e. a word, punctuation symbol, whitespace, etc.

Numeric_Comparison_Exp

Numeric_Comparison_Exp: { _eq?: Maybe<Scalars["numeric"]>; _gt?: Maybe<Scalars["numeric"]>; _gte?: Maybe<Scalars["numeric"]>; _in?: Maybe<Scalars["numeric"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["numeric"]>; _lte?: Maybe<Scalars["numeric"]>; _neq?: Maybe<Scalars["numeric"]>; _nin?: Maybe<Scalars["numeric"][]> }

Boolean expression to compare columns of type "numeric". All fields are combined with logical 'AND'.

Type declaration

Objects

Objects: { __typename?: "objects"; created_at: Scalars["timestamptz"]; metadata: Scalars["jsonb"]; object_id: Scalars["Int"] }

columns and relationships of "objects"

Type declaration

  • Optional __typename?: "objects"
  • created_at: Scalars["timestamptz"]
  • metadata: Scalars["jsonb"]
  • object_id: Scalars["Int"]

ObjectsMetadataArgs

ObjectsMetadataArgs: { path?: Maybe<Scalars["String"]> }

columns and relationships of "objects"

Type declaration

Objects_Aggregate

Objects_Aggregate: { __typename?: "objects_aggregate"; aggregate?: Maybe<Objects_Aggregate_Fields>; nodes: Objects[] }

aggregated selection of "objects"

Type declaration

Objects_Aggregate_Fields

Objects_Aggregate_Fields: { __typename?: "objects_aggregate_fields"; avg?: Maybe<Objects_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<Objects_Max_Fields>; min?: Maybe<Objects_Min_Fields>; stddev?: Maybe<Objects_Stddev_Fields>; stddev_pop?: Maybe<Objects_Stddev_Pop_Fields>; stddev_samp?: Maybe<Objects_Stddev_Samp_Fields>; sum?: Maybe<Objects_Sum_Fields>; var_pop?: Maybe<Objects_Var_Pop_Fields>; var_samp?: Maybe<Objects_Var_Samp_Fields>; variance?: Maybe<Objects_Variance_Fields> }

aggregate fields of "objects"

Type declaration

Objects_Aggregate_FieldsCountArgs

Objects_Aggregate_FieldsCountArgs: { columns?: Maybe<Objects_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "objects"

Type declaration

Objects_Append_Input

Objects_Append_Input: { metadata?: Maybe<Scalars["jsonb"]> }

append existing jsonb value of filtered columns with new jsonb value

Type declaration

Objects_Avg_Fields

Objects_Avg_Fields: { __typename?: "objects_avg_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "objects_avg_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Objects_Bool_Exp

Objects_Bool_Exp: { _and?: Maybe<Objects_Bool_Exp[]>; _not?: Maybe<Objects_Bool_Exp>; _or?: Maybe<Objects_Bool_Exp[]>; created_at?: Maybe<Timestamptz_Comparison_Exp>; metadata?: Maybe<Jsonb_Comparison_Exp>; object_id?: Maybe<Int_Comparison_Exp> }

Boolean expression to filter rows from the table "objects". All fields are combined with a logical 'AND'.

Type declaration

Objects_Delete_At_Path_Input

Objects_Delete_At_Path_Input: { metadata?: Maybe<Scalars["String"][]> }

delete the field or element with specified path (for JSON arrays, negative integers count from the end)

Type declaration

Objects_Delete_Elem_Input

Objects_Delete_Elem_Input: { metadata?: Maybe<Scalars["Int"]> }

delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array

Type declaration

Objects_Delete_Key_Input

Objects_Delete_Key_Input: { metadata?: Maybe<Scalars["String"]> }

delete key/value pair or string element. key/value pairs are matched based on their key value

Type declaration

Objects_Inc_Input

Objects_Inc_Input: { object_id?: Maybe<Scalars["Int"]> }

input type for incrementing numeric columns in table "objects"

Type declaration

Objects_Insert_Input

Objects_Insert_Input: { created_at?: Maybe<Scalars["timestamptz"]>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]> }

input type for inserting data into table "objects"

Type declaration

Objects_Max_Fields

Objects_Max_Fields: { __typename?: "objects_max_fields"; created_at?: Maybe<Scalars["timestamptz"]>; object_id?: Maybe<Scalars["Int"]> }

aggregate max on columns

Type declaration

  • Optional __typename?: "objects_max_fields"
  • Optional created_at?: Maybe<Scalars["timestamptz"]>
  • Optional object_id?: Maybe<Scalars["Int"]>

Objects_Min_Fields

Objects_Min_Fields: { __typename?: "objects_min_fields"; created_at?: Maybe<Scalars["timestamptz"]>; object_id?: Maybe<Scalars["Int"]> }

aggregate min on columns

Type declaration

  • Optional __typename?: "objects_min_fields"
  • Optional created_at?: Maybe<Scalars["timestamptz"]>
  • Optional object_id?: Maybe<Scalars["Int"]>

Objects_Mutation_Response

Objects_Mutation_Response: { __typename?: "objects_mutation_response"; affected_rows: Scalars["Int"]; returning: Objects[] }

response of any mutation on the table "objects"

Type declaration

  • Optional __typename?: "objects_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Objects[]

    data from the rows affected by the mutation

Objects_On_Conflict

Objects_On_Conflict: { constraint: Objects_Constraint; update_columns: Objects_Update_Column[]; where?: Maybe<Objects_Bool_Exp> }

on conflict condition type for table "objects"

Type declaration

Objects_Order_By

Objects_Order_By: { created_at?: Maybe<Order_By>; metadata?: Maybe<Order_By>; object_id?: Maybe<Order_By> }

Ordering options when selecting data from "objects".

Type declaration

Objects_Pk_Columns_Input

Objects_Pk_Columns_Input: { object_id: Scalars["Int"] }

primary key columns input for table: objects

Type declaration

Objects_Prepend_Input

Objects_Prepend_Input: { metadata?: Maybe<Scalars["jsonb"]> }

prepend existing jsonb value of filtered columns with new jsonb value

Type declaration

Objects_Set_Input

Objects_Set_Input: { created_at?: Maybe<Scalars["timestamptz"]>; metadata?: Maybe<Scalars["jsonb"]>; object_id?: Maybe<Scalars["Int"]> }

input type for updating data in table "objects"

Type declaration

Objects_Stddev_Fields

Objects_Stddev_Fields: { __typename?: "objects_stddev_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "objects_stddev_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Objects_Stddev_Pop_Fields

Objects_Stddev_Pop_Fields: { __typename?: "objects_stddev_pop_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "objects_stddev_pop_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Objects_Stddev_Samp_Fields

Objects_Stddev_Samp_Fields: { __typename?: "objects_stddev_samp_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "objects_stddev_samp_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Objects_Sum_Fields

Objects_Sum_Fields: { __typename?: "objects_sum_fields"; object_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "objects_sum_fields"
  • Optional object_id?: Maybe<Scalars["Int"]>

Objects_Var_Pop_Fields

Objects_Var_Pop_Fields: { __typename?: "objects_var_pop_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "objects_var_pop_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Objects_Var_Samp_Fields

Objects_Var_Samp_Fields: { __typename?: "objects_var_samp_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "objects_var_samp_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Objects_Variance_Fields

Objects_Variance_Fields: { __typename?: "objects_variance_fields"; object_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "objects_variance_fields"
  • Optional object_id?: Maybe<Scalars["Float"]>

Oid_Comparison_Exp

Oid_Comparison_Exp: { _eq?: Maybe<Scalars["oid"]>; _gt?: Maybe<Scalars["oid"]>; _gte?: Maybe<Scalars["oid"]>; _in?: Maybe<Scalars["oid"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["oid"]>; _lte?: Maybe<Scalars["oid"]>; _neq?: Maybe<Scalars["oid"]>; _nin?: Maybe<Scalars["oid"][]> }

Boolean expression to compare columns of type "oid". All fields are combined with logical 'AND'.

Type declaration

PairSimilarity

PairSimilarity: { __typename?: "PairSimilarity"; candidate?: Maybe<Scalars["String"]>; input?: Maybe<Scalars["String"]>; score?: Maybe<Scalars["Float"]> }

Type declaration

  • Optional __typename?: "PairSimilarity"
  • Optional candidate?: Maybe<Scalars["String"]>

    Similarity sentences pair

  • Optional input?: Maybe<Scalars["String"]>

    Similarity sentences pair

  • Optional score?: Maybe<Scalars["Float"]>

    Similarity score

Paraphrase

Paraphrase: { __typename?: "Paraphrase"; result?: Maybe<Maybe<Scalars["String"]>[]> }

Paraphrasing results

Type declaration

  • Optional __typename?: "Paraphrase"
  • Optional result?: Maybe<Maybe<Scalars["String"]>[]>

    A list of paraphrases

ParaphraseSentenceQuery

ParaphraseSentenceQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "Paraphrase" } & { paraphrases: Paraphrase["result"] }> }

ParaphraseSentenceQueryVariables

ParaphraseSentenceQueryVariables: Exact<{ input: Scalars["String"] }>

ParseAceQuery

ParseAceQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "ACEResult" } & { parsed: AceResult["result"] }> }

ParseAceQueryVariables

ParseAceQueryVariables: Exact<{ input: Scalars["String"]; type: AceOutputType }>

ParseContextQuery

ParseContextQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "ContextResult" } & { context?: Maybe<Maybe<{ __typename?: "SlingDocument" } & Pick<SlingDocument, "input"> & { mentions?: Maybe<Maybe<{ __typename?: "SlingMention" } & Pick<SlingMention, "evokes" | "phrase">>[]> }>[]> }> }

ParseContextQueryVariables

ParseContextQueryVariables: Exact<{ history: Turn[] | Turn }>

ParseTextQuery

ParseTextQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "NLUResult" } & { entities?: Maybe<Maybe<{ __typename?: "NLUSpan" } & Pick<NluSpan, "lemma" | "text"> & SubtreeFragment>[]>; noun_chunks?: Maybe<Maybe<{ __typename?: "NLUSpan" } & Pick<NluSpan, "lemma" | "text"> & SubtreeFragment>[]>; sentences?: Maybe<Maybe<{ __typename?: "NLUSpan" } & Pick<NluSpan, "text" | "lemma"> & SubtreeFragment>[]> }> }

ParseTextQueryVariables

ParseTextQueryVariables: Exact<{ input: Scalars["String"] }>

ParseTextTokensQuery

ParseTextTokensQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "NLUResult" } & { tokens?: Maybe<Maybe<{ __typename?: "NLUToken" } & TokenSubtreeFragment>[]> }> }

ParseTextTokensQueryVariables

ParseTextTokensQueryVariables: Exact<{ input: Scalars["String"] }>

PhraseMatch

PhraseMatch: { __typename?: "PhraseMatch"; matched_intent?: Maybe<Scalars["String"]>; similarity?: Maybe<Scalars["Float"]>; word_matches?: Maybe<Maybe<WordMatch>[]> }

A phrase match

Type declaration

  • Optional __typename?: "PhraseMatch"
  • Optional matched_intent?: Maybe<Scalars["String"]>

    The intent that get a match

  • Optional similarity?: Maybe<Scalars["Float"]>

    Similatiry measure

  • Optional word_matches?: Maybe<Maybe<WordMatch>[]>

    A list of word matches

PredictNextTurnQuery

PredictNextTurnQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "Result" } & { nextTurns?: Maybe<Maybe<{ __typename?: "DialogAlternative" } & Pick<DialogAlternative, "alternative" | "score">>[]> }> }

PredictNextTurnQueryVariables

PredictNextTurnQueryVariables: Exact<{ history: Turn[] | Turn; input: Scalars["String"][] | Scalars["String"] }>

Qa_Result

Qa_Result: { __typename?: "QA_Result"; result: Answer }

Answer to the given question

Type declaration

  • Optional __typename?: "QA_Result"
  • result: Answer

    Question-answer result

Query_Root

Query_Root: { __typename?: "query_root"; apps: Apps[]; apps_aggregate: Apps_Aggregate; atomic_data: Atomic_Data[]; atomic_data_aggregate: Atomic_Data_Aggregate; audit_logged_actions: Audit_Logged_Actions[]; audit_logged_actions_aggregate: Audit_Logged_Actions_Aggregate; audit_logged_actions_by_pk?: Maybe<Audit_Logged_Actions>; callApplyVoiceCSS?: Maybe<SsmlResult>; callChitchat?: Maybe<ChitchatResponse>; callClassifyTopic?: Maybe<ClassificationResult>; callCommonsense?: Maybe<RelationResult>; callCompose?: Maybe<ComposeResult>; callMatchIntent?: Maybe<MatchIntentOutput>; callMeasureSimilarity?: Maybe<SentenceSimilarityScores>; callNLU?: Maybe<NluResult>; callNextDialogTurn?: Maybe<Result>; callParaphraseSentence?: Maybe<Paraphrase>; callParseACE?: Maybe<AceResult>; callParseContext?: Maybe<ContextResult>; callPredictRelation?: Maybe<RelationResult>; callQA?: Maybe<Qa_Result>; callResolveCoreference?: Maybe<CorefResult>; callSentimentAnalysis?: Maybe<Maybe<SentimentAnalysisResult>[]>; callShowDocs?: Maybe<ServiceInfo>; callSpeechToText: SttResult; callTextToSpeech?: Maybe<TtsResult>; conceptnet_data: Conceptnet_Data[]; conceptnet_data_aggregate: Conceptnet_Data_Aggregate; conceptnet_search_relations: Conceptnet_Data[]; conceptnet_search_relations_aggregate: Conceptnet_Data_Aggregate; conversations: Conversations[]; conversations_aggregate: Conversations_Aggregate; deprecatedCallNlpDoc?: Maybe<NlpDoc>; developers: Developers[]; developers_aggregate: Developers_Aggregate; end_user_conversations: End_User_Conversations[]; end_user_conversations_aggregate: End_User_Conversations_Aggregate; end_user_conversations_by_pk?: Maybe<End_User_Conversations>; end_users: End_Users[]; end_users_aggregate: End_Users_Aggregate; events: Events[]; events_aggregate: Events_Aggregate; history: History[]; history_aggregate: History_Aggregate; kv_scope_enum: Kv_Scope_Enum[]; kv_scope_enum_aggregate: Kv_Scope_Enum_Aggregate; kv_scope_enum_by_pk?: Maybe<Kv_Scope_Enum>; kv_store: Kv_Store[]; kv_store_aggregate: Kv_Store_Aggregate; kv_store_by_pk?: Maybe<Kv_Store>; last_utterance: Last_Utterance[]; last_utterance_aggregate: Last_Utterance_Aggregate; me: Developers[]; me_aggregate: Developers_Aggregate; objects: Objects[]; objects_aggregate: Objects_Aggregate; objects_by_pk?: Maybe<Objects>; speaker_type_enum: Speaker_Type_Enum[]; speaker_type_enum_aggregate: Speaker_Type_Enum_Aggregate; speaker_type_enum_by_pk?: Maybe<Speaker_Type_Enum>; utterances: Utterances[]; utterances_aggregate: Utterances_Aggregate }

Type declaration

Query_RootAppsArgs

Query_RootAppsArgs: { distinct_on?: Maybe<Apps_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Apps_Order_By[]>; where?: Maybe<Apps_Bool_Exp> }

Type declaration

Query_RootApps_AggregateArgs

Query_RootApps_AggregateArgs: { distinct_on?: Maybe<Apps_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Apps_Order_By[]>; where?: Maybe<Apps_Bool_Exp> }

Type declaration

Query_RootAtomic_DataArgs

Query_RootAtomic_DataArgs: { distinct_on?: Maybe<Atomic_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Atomic_Data_Order_By[]>; where?: Maybe<Atomic_Data_Bool_Exp> }

Type declaration

Query_RootAtomic_Data_AggregateArgs

Query_RootAtomic_Data_AggregateArgs: { distinct_on?: Maybe<Atomic_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Atomic_Data_Order_By[]>; where?: Maybe<Atomic_Data_Bool_Exp> }

Type declaration

Query_RootAudit_Logged_ActionsArgs

Query_RootAudit_Logged_ActionsArgs: { distinct_on?: Maybe<Audit_Logged_Actions_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Audit_Logged_Actions_Order_By[]>; where?: Maybe<Audit_Logged_Actions_Bool_Exp> }

Type declaration

Query_RootAudit_Logged_Actions_AggregateArgs

Query_RootAudit_Logged_Actions_AggregateArgs: { distinct_on?: Maybe<Audit_Logged_Actions_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Audit_Logged_Actions_Order_By[]>; where?: Maybe<Audit_Logged_Actions_Bool_Exp> }

Type declaration

Query_RootAudit_Logged_Actions_By_PkArgs

Query_RootAudit_Logged_Actions_By_PkArgs: { action_tstamp_stm: Scalars["timestamptz"]; event_id: Scalars["bigint"] }

Type declaration

  • action_tstamp_stm: Scalars["timestamptz"]
  • event_id: Scalars["bigint"]

Query_RootCallApplyVoiceCssArgs

Query_RootCallApplyVoiceCssArgs: { css?: Maybe<Scalars["String"]>; ssml?: Maybe<Scalars["String"]> }

Type declaration

Query_RootCallChitchatArgs

Query_RootCallChitchatArgs: { history?: Maybe<Turn[]>; input?: Maybe<Scalars["String"]> }

Type declaration

Query_RootCallClassifyTopicArgs

Query_RootCallClassifyTopicArgs: { allow_multiple?: Maybe<Scalars["Boolean"]>; input: Scalars["String"]; topics?: Maybe<Scalars["String"][]> }

Type declaration

Query_RootCallCommonsenseArgs

Query_RootCallCommonsenseArgs: { category?: Maybe<Category>; input: Scalars["String"] }

Type declaration

Query_RootCallComposeArgs

Query_RootCallComposeArgs: { init?: Maybe<Scalars["JSON"]>; pipeline: Maybe<InputPipe>[] }

Type declaration

Query_RootCallMatchIntentArgs

Query_RootCallMatchIntentArgs: { input?: Maybe<Scalars["String"]>; possible_intents?: Maybe<Maybe<Scalars["String"]>[]>; similarity_threshold?: Maybe<Scalars["Float"]> }

Type declaration

Query_RootCallMeasureSimilarityArgs

Query_RootCallMeasureSimilarityArgs: { candidates?: Maybe<Maybe<Scalars["String"]>[]>; input?: Maybe<Scalars["String"]> }

Type declaration

Query_RootCallNextDialogTurnArgs

Query_RootCallNextDialogTurnArgs: { history?: Maybe<Turn[]>; input?: Maybe<Maybe<Scalars["String"]>[]> }

Type declaration

Query_RootCallNluArgs

Query_RootCallNluArgs: { input: Scalars["String"] }

Type declaration

Query_RootCallParaphraseSentenceArgs

Query_RootCallParaphraseSentenceArgs: { input?: Maybe<Scalars["String"]> }

Type declaration

Query_RootCallParseAceArgs

Query_RootCallParseAceArgs: { input: Scalars["String"]; type?: Maybe<AceOutputType> }

Type declaration

Query_RootCallParseContextArgs

Query_RootCallParseContextArgs: { history?: Maybe<Turn[]> }

Type declaration

Query_RootCallPredictRelationArgs

Query_RootCallPredictRelationArgs: { input: Scalars["String"]; relation?: Maybe<Relation> }

Type declaration

Query_RootCallQaArgs

Query_RootCallQaArgs: { allow_impossible?: Maybe<Scalars["Boolean"]>; context: Scalars["String"]; input: Scalars["String"] }

Type declaration

Query_RootCallResolveCoreferenceArgs

Query_RootCallResolveCoreferenceArgs: { input: Scalars["String"] }

Type declaration

Query_RootCallSentimentAnalysisArgs

Query_RootCallSentimentAnalysisArgs: { input: Scalars["String"] }

Type declaration

Query_RootCallShowDocsArgs

Query_RootCallShowDocsArgs: { service?: Maybe<ServiceName> }

Type declaration

Query_RootCallSpeechToTextArgs

Query_RootCallSpeechToTextArgs: { config?: Maybe<SttConfig>; input: Scalars["String"] }

Type declaration

Query_RootCallTextToSpeechArgs

Query_RootCallTextToSpeechArgs: { config?: Maybe<TtsConfig>; input: Scalars["String"] }

Type declaration

Query_RootConceptnet_DataArgs

Query_RootConceptnet_DataArgs: { distinct_on?: Maybe<Conceptnet_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conceptnet_Data_Order_By[]>; where?: Maybe<Conceptnet_Data_Bool_Exp> }

Type declaration

Query_RootConceptnet_Data_AggregateArgs

Query_RootConceptnet_Data_AggregateArgs: { distinct_on?: Maybe<Conceptnet_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conceptnet_Data_Order_By[]>; where?: Maybe<Conceptnet_Data_Bool_Exp> }

Type declaration

Query_RootConceptnet_Search_RelationsArgs

Query_RootConceptnet_Search_RelationsArgs: { args: Conceptnet_Search_Relations_Args; distinct_on?: Maybe<Conceptnet_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conceptnet_Data_Order_By[]>; where?: Maybe<Conceptnet_Data_Bool_Exp> }

Type declaration

Query_RootConceptnet_Search_Relations_AggregateArgs

Query_RootConceptnet_Search_Relations_AggregateArgs: { args: Conceptnet_Search_Relations_Args; distinct_on?: Maybe<Conceptnet_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conceptnet_Data_Order_By[]>; where?: Maybe<Conceptnet_Data_Bool_Exp> }

Type declaration

Query_RootConversationsArgs

Query_RootConversationsArgs: { distinct_on?: Maybe<Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conversations_Order_By[]>; where?: Maybe<Conversations_Bool_Exp> }

Type declaration

Query_RootConversations_AggregateArgs

Query_RootConversations_AggregateArgs: { distinct_on?: Maybe<Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conversations_Order_By[]>; where?: Maybe<Conversations_Bool_Exp> }

Type declaration

Query_RootDeprecatedCallNlpDocArgs

Query_RootDeprecatedCallNlpDocArgs: { disable?: Maybe<Maybe<Scalars["String"]>[]>; input: Scalars["String"]; model?: Maybe<Scalars["String"]> }

Type declaration

Query_RootDevelopersArgs

Query_RootDevelopersArgs: { distinct_on?: Maybe<Developers_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Developers_Order_By[]>; where?: Maybe<Developers_Bool_Exp> }

Type declaration

Query_RootDevelopers_AggregateArgs

Query_RootDevelopers_AggregateArgs: { distinct_on?: Maybe<Developers_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Developers_Order_By[]>; where?: Maybe<Developers_Bool_Exp> }

Type declaration

Query_RootEnd_User_ConversationsArgs

Query_RootEnd_User_ConversationsArgs: { distinct_on?: Maybe<End_User_Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_User_Conversations_Order_By[]>; where?: Maybe<End_User_Conversations_Bool_Exp> }

Type declaration

Query_RootEnd_User_Conversations_AggregateArgs

Query_RootEnd_User_Conversations_AggregateArgs: { distinct_on?: Maybe<End_User_Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_User_Conversations_Order_By[]>; where?: Maybe<End_User_Conversations_Bool_Exp> }

Type declaration

Query_RootEnd_User_Conversations_By_PkArgs

Query_RootEnd_User_Conversations_By_PkArgs: { conversation_id: Scalars["Int"]; end_user_id: Scalars["Int"] }

Type declaration

Query_RootEnd_UsersArgs

Query_RootEnd_UsersArgs: { distinct_on?: Maybe<End_Users_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_Users_Order_By[]>; where?: Maybe<End_Users_Bool_Exp> }

Type declaration

Query_RootEnd_Users_AggregateArgs

Query_RootEnd_Users_AggregateArgs: { distinct_on?: Maybe<End_Users_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_Users_Order_By[]>; where?: Maybe<End_Users_Bool_Exp> }

Type declaration

Query_RootEventsArgs

Query_RootEventsArgs: { distinct_on?: Maybe<Events_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Events_Order_By[]>; where?: Maybe<Events_Bool_Exp> }

Type declaration

Query_RootEvents_AggregateArgs

Query_RootEvents_AggregateArgs: { distinct_on?: Maybe<Events_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Events_Order_By[]>; where?: Maybe<Events_Bool_Exp> }

Type declaration

Query_RootHistoryArgs

Query_RootHistoryArgs: { distinct_on?: Maybe<History_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<History_Order_By[]>; where?: Maybe<History_Bool_Exp> }

Type declaration

Query_RootHistory_AggregateArgs

Query_RootHistory_AggregateArgs: { distinct_on?: Maybe<History_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<History_Order_By[]>; where?: Maybe<History_Bool_Exp> }

Type declaration

Query_RootKv_Scope_EnumArgs

Query_RootKv_Scope_EnumArgs: { distinct_on?: Maybe<Kv_Scope_Enum_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Scope_Enum_Order_By[]>; where?: Maybe<Kv_Scope_Enum_Bool_Exp> }

Type declaration

Query_RootKv_Scope_Enum_AggregateArgs

Query_RootKv_Scope_Enum_AggregateArgs: { distinct_on?: Maybe<Kv_Scope_Enum_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Scope_Enum_Order_By[]>; where?: Maybe<Kv_Scope_Enum_Bool_Exp> }

Type declaration

Query_RootKv_Scope_Enum_By_PkArgs

Query_RootKv_Scope_Enum_By_PkArgs: { value: Scalars["String"] }

Type declaration

Query_RootKv_StoreArgs

Query_RootKv_StoreArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

Type declaration

Query_RootKv_Store_AggregateArgs

Query_RootKv_Store_AggregateArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

Type declaration

Query_RootKv_Store_By_PkArgs

Query_RootKv_Store_By_PkArgs: { key: Scalars["String"]; scope: Scalars["String"]; scope_object_id: Scalars["Int"] }

Type declaration

Query_RootLast_UtteranceArgs

Query_RootLast_UtteranceArgs: { distinct_on?: Maybe<Last_Utterance_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Last_Utterance_Order_By[]>; where?: Maybe<Last_Utterance_Bool_Exp> }

Type declaration

Query_RootLast_Utterance_AggregateArgs

Query_RootLast_Utterance_AggregateArgs: { distinct_on?: Maybe<Last_Utterance_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Last_Utterance_Order_By[]>; where?: Maybe<Last_Utterance_Bool_Exp> }

Type declaration

Query_RootMeArgs

Query_RootMeArgs: { distinct_on?: Maybe<Developers_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Developers_Order_By[]>; where?: Maybe<Developers_Bool_Exp> }

Type declaration

Query_RootMe_AggregateArgs

Query_RootMe_AggregateArgs: { distinct_on?: Maybe<Developers_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Developers_Order_By[]>; where?: Maybe<Developers_Bool_Exp> }

Type declaration

Query_RootObjectsArgs

Query_RootObjectsArgs: { distinct_on?: Maybe<Objects_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Objects_Order_By[]>; where?: Maybe<Objects_Bool_Exp> }

Type declaration

Query_RootObjects_AggregateArgs

Query_RootObjects_AggregateArgs: { distinct_on?: Maybe<Objects_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Objects_Order_By[]>; where?: Maybe<Objects_Bool_Exp> }

Type declaration

Query_RootObjects_By_PkArgs

Query_RootObjects_By_PkArgs: { object_id: Scalars["Int"] }

Type declaration

Query_RootSpeaker_Type_EnumArgs

Query_RootSpeaker_Type_EnumArgs: { distinct_on?: Maybe<Speaker_Type_Enum_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Speaker_Type_Enum_Order_By[]>; where?: Maybe<Speaker_Type_Enum_Bool_Exp> }

Type declaration

Query_RootSpeaker_Type_Enum_AggregateArgs

Query_RootSpeaker_Type_Enum_AggregateArgs: { distinct_on?: Maybe<Speaker_Type_Enum_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Speaker_Type_Enum_Order_By[]>; where?: Maybe<Speaker_Type_Enum_Bool_Exp> }

Type declaration

Query_RootSpeaker_Type_Enum_By_PkArgs

Query_RootSpeaker_Type_Enum_By_PkArgs: { value: Scalars["String"] }

Type declaration

Query_RootUtterancesArgs

Query_RootUtterancesArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

Type declaration

Query_RootUtterances_AggregateArgs

Query_RootUtterances_AggregateArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

Type declaration

RelationResult

RelationResult: { __typename?: "RelationResult"; result?: Maybe<Maybe<Scalars["String"]>[]> }

Type declaration

  • Optional __typename?: "RelationResult"
  • Optional result?: Maybe<Maybe<Scalars["String"]>[]>

    Extracted relations

RenderCssQuery

RenderCssQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "SSMLResult" } & { ssml: SsmlResult["result"] }> }

RenderCssQueryVariables

RenderCssQueryVariables: Exact<{ css: Scalars["String"]; ssml: Scalars["String"] }>

ResolveCoreferencesQuery

ResolveCoreferencesQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "CorefResult" } & Pick<CorefResult, "has_coreference"> & { resolved_text: CorefResult["result"] } & { coreferences?: Maybe<Maybe<{ __typename?: "CorefResultScores" } & Pick<CorefResultScores, "mention"> & { reference?: Maybe<Maybe<{ __typename?: "ResultScores" } & Pick<ResultScores, "score" | "text">>[]> }>[]> }> }

ResolveCoreferencesQueryVariables

ResolveCoreferencesQueryVariables: Exact<{ input: Scalars["String"] }>

Result

Result: { __typename?: "Result"; result?: Maybe<Maybe<DialogAlternative>[]> }

Turn prediction result

Type declaration

ResultScores

ResultScores: { __typename?: "ResultScores"; score?: Maybe<Scalars["Float"]>; text?: Maybe<Scalars["String"]> }

Type declaration

  • Optional __typename?: "ResultScores"
  • Optional score?: Maybe<Scalars["Float"]>

    Score of the coreference resolution for this mention

  • Optional text?: Maybe<Scalars["String"]>

    Mention text

Scalars

Scalars: { Boolean: boolean; Float: number; ID: string; Int: number; JSON: any; String: string; _text: any; app_status: any; bigint: any; inet: any; jsonb: any; numeric: any; oid: any; timestamptz: any; tstzrange: any }

All built-in and custom scalars, mapped to their actual values

Type declaration

  • Boolean: boolean
  • Float: number
  • ID: string
  • Int: number
  • JSON: any

    The JSON scalar type represents JSON values as specified by ECMA-404.

  • String: string
  • _text: any
  • app_status: any
  • bigint: any
  • inet: any
  • jsonb: any
  • numeric: any
  • oid: any
  • timestamptz: any
  • tstzrange: any

Scores

Scores: { __typename?: "Scores"; mention?: Maybe<Scalars["String"]>; score?: Maybe<Scalars["Float"]> }

Type declaration

  • Optional __typename?: "Scores"
  • Optional mention?: Maybe<Scalars["String"]>

    Mention text

  • Optional score?: Maybe<Scalars["Float"]>

    Score of the coreference resolution for this mention

SentenceSimilarityScores

SentenceSimilarityScores: { __typename?: "SentenceSimilarityScores"; result?: Maybe<Maybe<PairSimilarity>[]> }

Sentence similarity score

Type declaration

  • Optional __typename?: "SentenceSimilarityScores"
  • Optional result?: Maybe<Maybe<PairSimilarity>[]>

    A list of pair similarity results

SentimentAnalysisResult

SentimentAnalysisResult: { __typename?: "SentimentAnalysisResult"; label?: Maybe<Scalars["String"]>; score?: Maybe<Scalars["Float"]> }

Type declaration

  • Optional __typename?: "SentimentAnalysisResult"
  • Optional label?: Maybe<Scalars["String"]>

    Sentiment label

  • Optional score?: Maybe<Scalars["Float"]>

    Sentiment score

ServiceInfo

ServiceInfo: { __typename?: "ServiceInfo"; enums?: Maybe<Scalars["String"]>; inputs?: Maybe<Scalars["String"]>; interfaces?: Maybe<Scalars["String"]>; objects?: Maybe<Scalars["String"]>; queries?: Maybe<Scalars["String"]>; scalars?: Maybe<Scalars["String"]>; schema?: Maybe<Scalars["String"]> }

Type declaration

SlingDocument

SlingDocument: { __typename?: "SlingDocument"; input?: Maybe<Scalars["String"]>; mentions?: Maybe<Maybe<SlingMention>[]> }

SLING document

Type declaration

SlingMention

SlingMention: { __typename?: "SlingMention"; evokes?: Maybe<Maybe<Scalars["String"]>[]>; phrase?: Maybe<Scalars["String"]> }

SLING mention

Type declaration

  • Optional __typename?: "SlingMention"
  • Optional evokes?: Maybe<Maybe<Scalars["String"]>[]>

    List of words this mention evokes

  • Optional phrase?: Maybe<Scalars["String"]>

    Mention phrase

Span

Span: Container & { __typename?: "Span"; conjuncts?: Maybe<Maybe<Token>[]>; end?: Maybe<Scalars["Int"]>; ents?: Maybe<Maybe<Span>[]>; extension?: Maybe<SpanExtension>; has_vector?: Maybe<Scalars["Boolean"]>; label?: Maybe<Scalars["String"]>; lefts?: Maybe<Maybe<Token>[]>; lemma?: Maybe<Scalars["String"]>; rights?: Maybe<Maybe<Token>[]>; root?: Maybe<Token>; start?: Maybe<Scalars["Int"]>; subtree?: Maybe<Maybe<Token>[]>; text?: Maybe<Scalars["String"]>; text_with_ws?: Maybe<Scalars["String"]>; tokens?: Maybe<Maybe<Token>[]>; vector?: Maybe<Maybe<Scalars["Float"]>[]>; vector_norm?: Maybe<Scalars["Float"]> }

A slice from a Doc object

SpanExtension

SpanExtension: { __typename?: "SpanExtension"; coref_cluster?: Maybe<CorefCluster>; coref_scores?: Maybe<Maybe<Scores>[]>; is_coref?: Maybe<Scalars["Boolean"]> }

Type declaration

  • Optional __typename?: "SpanExtension"
  • Optional coref_cluster?: Maybe<CorefCluster>

    All the clusters of corefering mentions in the doc

  • Optional coref_scores?: Maybe<Maybe<Scores>[]>

    Scores of the coreference resolution between mentions

  • Optional is_coref?: Maybe<Scalars["Boolean"]>

    Is the span a coreference?

Speaker_Type_Enum

Speaker_Type_Enum: { __typename?: "speaker_type_enum"; utterances: Utterances[]; utterances_aggregate: Utterances_Aggregate; value: Scalars["String"] }

columns and relationships of "speaker_type_enum"

Type declaration

Speaker_Type_EnumUtterancesArgs

Speaker_Type_EnumUtterancesArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

columns and relationships of "speaker_type_enum"

Type declaration

Speaker_Type_EnumUtterances_AggregateArgs

Speaker_Type_EnumUtterances_AggregateArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

columns and relationships of "speaker_type_enum"

Type declaration

Speaker_Type_Enum_Aggregate

Speaker_Type_Enum_Aggregate: { __typename?: "speaker_type_enum_aggregate"; aggregate?: Maybe<Speaker_Type_Enum_Aggregate_Fields>; nodes: Speaker_Type_Enum[] }

aggregated selection of "speaker_type_enum"

Type declaration

Speaker_Type_Enum_Aggregate_Fields

Speaker_Type_Enum_Aggregate_Fields: { __typename?: "speaker_type_enum_aggregate_fields"; count: Scalars["Int"]; max?: Maybe<Speaker_Type_Enum_Max_Fields>; min?: Maybe<Speaker_Type_Enum_Min_Fields> }

aggregate fields of "speaker_type_enum"

Type declaration

Speaker_Type_Enum_Aggregate_FieldsCountArgs

Speaker_Type_Enum_Aggregate_FieldsCountArgs: { columns?: Maybe<Speaker_Type_Enum_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "speaker_type_enum"

Type declaration

Speaker_Type_Enum_Bool_Exp

Boolean expression to filter rows from the table "speaker_type_enum". All fields are combined with a logical 'AND'.

Type declaration

Speaker_Type_Enum_Enum_Comparison_Exp

Speaker_Type_Enum_Enum_Comparison_Exp: { _eq?: Maybe<Speaker_Type_Enum_Enum>; _in?: Maybe<Speaker_Type_Enum_Enum[]>; _is_null?: Maybe<Scalars["Boolean"]>; _neq?: Maybe<Speaker_Type_Enum_Enum>; _nin?: Maybe<Speaker_Type_Enum_Enum[]> }

Boolean expression to compare columns of type "speaker_type_enum_enum". All fields are combined with logical 'AND'.

Type declaration

Speaker_Type_Enum_Insert_Input

Speaker_Type_Enum_Insert_Input: { utterances?: Maybe<Utterances_Arr_Rel_Insert_Input>; value?: Maybe<Scalars["String"]> }

input type for inserting data into table "speaker_type_enum"

Type declaration

Speaker_Type_Enum_Max_Fields

Speaker_Type_Enum_Max_Fields: { __typename?: "speaker_type_enum_max_fields"; value?: Maybe<Scalars["String"]> }

aggregate max on columns

Type declaration

  • Optional __typename?: "speaker_type_enum_max_fields"
  • Optional value?: Maybe<Scalars["String"]>

Speaker_Type_Enum_Min_Fields

Speaker_Type_Enum_Min_Fields: { __typename?: "speaker_type_enum_min_fields"; value?: Maybe<Scalars["String"]> }

aggregate min on columns

Type declaration

  • Optional __typename?: "speaker_type_enum_min_fields"
  • Optional value?: Maybe<Scalars["String"]>

Speaker_Type_Enum_Mutation_Response

Speaker_Type_Enum_Mutation_Response: { __typename?: "speaker_type_enum_mutation_response"; affected_rows: Scalars["Int"]; returning: Speaker_Type_Enum[] }

response of any mutation on the table "speaker_type_enum"

Type declaration

  • Optional __typename?: "speaker_type_enum_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Speaker_Type_Enum[]

    data from the rows affected by the mutation

Speaker_Type_Enum_Obj_Rel_Insert_Input

Speaker_Type_Enum_Obj_Rel_Insert_Input: { data: Speaker_Type_Enum_Insert_Input; on_conflict?: Maybe<Speaker_Type_Enum_On_Conflict> }

input type for inserting object relation for remote table "speaker_type_enum"

Type declaration

Speaker_Type_Enum_On_Conflict

Speaker_Type_Enum_On_Conflict: { constraint: Speaker_Type_Enum_Constraint; update_columns: Speaker_Type_Enum_Update_Column[]; where?: Maybe<Speaker_Type_Enum_Bool_Exp> }

on conflict condition type for table "speaker_type_enum"

Type declaration

Speaker_Type_Enum_Order_By

Speaker_Type_Enum_Order_By: { utterances_aggregate?: Maybe<Utterances_Aggregate_Order_By>; value?: Maybe<Order_By> }

Ordering options when selecting data from "speaker_type_enum".

Type declaration

Speaker_Type_Enum_Pk_Columns_Input

Speaker_Type_Enum_Pk_Columns_Input: { value: Scalars["String"] }

primary key columns input for table: speaker_type_enum

Type declaration

Speaker_Type_Enum_Set_Input

Speaker_Type_Enum_Set_Input: { value?: Maybe<Scalars["String"]> }

input type for updating data in table "speaker_type_enum"

Type declaration

SpeechToTextQuery

SpeechToTextQuery: { __typename?: "query_root" } & { result: { __typename?: "STTResult" } & { transcript: SttResult["result"] } }

SpeechToTextQueryVariables

SpeechToTextQueryVariables: Exact<{ input: Scalars["String"] }>

SsmlResult

SsmlResult: { __typename?: "SSMLResult"; result?: Maybe<Scalars["String"]> }

Output result

Type declaration

  • Optional __typename?: "SSMLResult"
  • Optional result?: Maybe<Scalars["String"]>

    Rendered SSML

String_Comparison_Exp

String_Comparison_Exp: { _eq?: Maybe<Scalars["String"]>; _gt?: Maybe<Scalars["String"]>; _gte?: Maybe<Scalars["String"]>; _ilike?: Maybe<Scalars["String"]>; _in?: Maybe<Scalars["String"][]>; _iregex?: Maybe<Scalars["String"]>; _is_null?: Maybe<Scalars["Boolean"]>; _like?: Maybe<Scalars["String"]>; _lt?: Maybe<Scalars["String"]>; _lte?: Maybe<Scalars["String"]>; _neq?: Maybe<Scalars["String"]>; _nilike?: Maybe<Scalars["String"]>; _nin?: Maybe<Scalars["String"][]>; _niregex?: Maybe<Scalars["String"]>; _nlike?: Maybe<Scalars["String"]>; _nregex?: Maybe<Scalars["String"]>; _nsimilar?: Maybe<Scalars["String"]>; _regex?: Maybe<Scalars["String"]>; _similar?: Maybe<Scalars["String"]> }

Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'.

Type declaration

  • Optional _eq?: Maybe<Scalars["String"]>
  • Optional _gt?: Maybe<Scalars["String"]>
  • Optional _gte?: Maybe<Scalars["String"]>
  • Optional _ilike?: Maybe<Scalars["String"]>

    does the column match the given case-insensitive pattern

  • Optional _in?: Maybe<Scalars["String"][]>
  • Optional _iregex?: Maybe<Scalars["String"]>

    does the column match the given POSIX regular expression, case insensitive

  • Optional _is_null?: Maybe<Scalars["Boolean"]>
  • Optional _like?: Maybe<Scalars["String"]>

    does the column match the given pattern

  • Optional _lt?: Maybe<Scalars["String"]>
  • Optional _lte?: Maybe<Scalars["String"]>
  • Optional _neq?: Maybe<Scalars["String"]>
  • Optional _nilike?: Maybe<Scalars["String"]>

    does the column NOT match the given case-insensitive pattern

  • Optional _nin?: Maybe<Scalars["String"][]>
  • Optional _niregex?: Maybe<Scalars["String"]>

    does the column NOT match the given POSIX regular expression, case insensitive

  • Optional _nlike?: Maybe<Scalars["String"]>

    does the column NOT match the given pattern

  • Optional _nregex?: Maybe<Scalars["String"]>

    does the column NOT match the given POSIX regular expression, case sensitive

  • Optional _nsimilar?: Maybe<Scalars["String"]>

    does the column NOT match the given SQL regular expression

  • Optional _regex?: Maybe<Scalars["String"]>

    does the column match the given POSIX regular expression, case sensitive

  • Optional _similar?: Maybe<Scalars["String"]>

    does the column match the given SQL regular expression

SttConfig

SttConfig: { encoding?: Maybe<Encoding>; sampleRate?: Maybe<Scalars["Int"]> }

Speech to text config

Type declaration

SttResult

SttResult: { __typename?: "STTResult"; result?: Maybe<Scalars["String"]> }

Output result

Type declaration

  • Optional __typename?: "STTResult"
  • Optional result?: Maybe<Scalars["String"]>

    Transcription

Subscription_Root

Subscription_Root: { __typename?: "subscription_root"; apps: Apps[]; apps_aggregate: Apps_Aggregate; atomic_data: Atomic_Data[]; atomic_data_aggregate: Atomic_Data_Aggregate; audit_logged_actions: Audit_Logged_Actions[]; audit_logged_actions_aggregate: Audit_Logged_Actions_Aggregate; audit_logged_actions_by_pk?: Maybe<Audit_Logged_Actions>; conceptnet_data: Conceptnet_Data[]; conceptnet_data_aggregate: Conceptnet_Data_Aggregate; conceptnet_search_relations: Conceptnet_Data[]; conceptnet_search_relations_aggregate: Conceptnet_Data_Aggregate; conversations: Conversations[]; conversations_aggregate: Conversations_Aggregate; developers: Developers[]; developers_aggregate: Developers_Aggregate; end_user_conversations: End_User_Conversations[]; end_user_conversations_aggregate: End_User_Conversations_Aggregate; end_user_conversations_by_pk?: Maybe<End_User_Conversations>; end_users: End_Users[]; end_users_aggregate: End_Users_Aggregate; events: Events[]; events_aggregate: Events_Aggregate; history: History[]; history_aggregate: History_Aggregate; kv_scope_enum: Kv_Scope_Enum[]; kv_scope_enum_aggregate: Kv_Scope_Enum_Aggregate; kv_scope_enum_by_pk?: Maybe<Kv_Scope_Enum>; kv_store: Kv_Store[]; kv_store_aggregate: Kv_Store_Aggregate; kv_store_by_pk?: Maybe<Kv_Store>; last_utterance: Last_Utterance[]; last_utterance_aggregate: Last_Utterance_Aggregate; me: Developers[]; me_aggregate: Developers_Aggregate; objects: Objects[]; objects_aggregate: Objects_Aggregate; objects_by_pk?: Maybe<Objects>; speaker_type_enum: Speaker_Type_Enum[]; speaker_type_enum_aggregate: Speaker_Type_Enum_Aggregate; speaker_type_enum_by_pk?: Maybe<Speaker_Type_Enum>; utterances: Utterances[]; utterances_aggregate: Utterances_Aggregate }

Type declaration

  • Optional __typename?: "subscription_root"
  • apps: Apps[]

    An array relationship

  • apps_aggregate: Apps_Aggregate

    An aggregate relationship

  • atomic_data: Atomic_Data[]

    fetch data from the table: "atomic.data"

  • atomic_data_aggregate: Atomic_Data_Aggregate

    fetch aggregated fields from the table: "atomic.data"

  • audit_logged_actions: Audit_Logged_Actions[]

    fetch data from the table: "audit.logged_actions"

  • audit_logged_actions_aggregate: Audit_Logged_Actions_Aggregate

    fetch aggregated fields from the table: "audit.logged_actions"

  • Optional audit_logged_actions_by_pk?: Maybe<Audit_Logged_Actions>

    fetch data from the table: "audit.logged_actions" using primary key columns

  • conceptnet_data: Conceptnet_Data[]

    fetch data from the table: "conceptnet.data"

  • conceptnet_data_aggregate: Conceptnet_Data_Aggregate

    fetch aggregated fields from the table: "conceptnet.data"

  • conceptnet_search_relations: Conceptnet_Data[]

    execute function "conceptnet.search_relations" which returns "conceptnet.data"

  • conceptnet_search_relations_aggregate: Conceptnet_Data_Aggregate

    execute function "conceptnet.search_relations" and query aggregates on result of table type "conceptnet.data"

  • conversations: Conversations[]

    An array relationship

  • conversations_aggregate: Conversations_Aggregate

    An aggregate relationship

  • developers: Developers[]

    fetch data from the table: "developers"

  • developers_aggregate: Developers_Aggregate

    fetch aggregated fields from the table: "developers"

  • end_user_conversations: End_User_Conversations[]

    An array relationship

  • end_user_conversations_aggregate: End_User_Conversations_Aggregate

    An aggregate relationship

  • Optional end_user_conversations_by_pk?: Maybe<End_User_Conversations>

    fetch data from the table: "end_user_conversations" using primary key columns

  • end_users: End_Users[]

    fetch data from the table: "end_users"

  • end_users_aggregate: End_Users_Aggregate

    fetch aggregated fields from the table: "end_users"

  • events: Events[]

    An array relationship

  • events_aggregate: Events_Aggregate

    An aggregate relationship

  • history: History[]

    fetch data from the table: "history"

  • history_aggregate: History_Aggregate

    fetch aggregated fields from the table: "history"

  • kv_scope_enum: Kv_Scope_Enum[]

    fetch data from the table: "kv_scope_enum"

  • kv_scope_enum_aggregate: Kv_Scope_Enum_Aggregate

    fetch aggregated fields from the table: "kv_scope_enum"

  • Optional kv_scope_enum_by_pk?: Maybe<Kv_Scope_Enum>

    fetch data from the table: "kv_scope_enum" using primary key columns

  • kv_store: Kv_Store[]

    An array relationship

  • kv_store_aggregate: Kv_Store_Aggregate

    An aggregate relationship

  • Optional kv_store_by_pk?: Maybe<Kv_Store>

    fetch data from the table: "kv_store" using primary key columns

  • last_utterance: Last_Utterance[]

    fetch data from the table: "last_utterance"

  • last_utterance_aggregate: Last_Utterance_Aggregate

    fetch aggregated fields from the table: "last_utterance"

  • me: Developers[]

    execute function "me" which returns "developers"

  • me_aggregate: Developers_Aggregate

    execute function "me" and query aggregates on result of table type "developers"

  • objects: Objects[]

    fetch data from the table: "objects"

  • objects_aggregate: Objects_Aggregate

    fetch aggregated fields from the table: "objects"

  • Optional objects_by_pk?: Maybe<Objects>

    fetch data from the table: "objects" using primary key columns

  • speaker_type_enum: Speaker_Type_Enum[]

    fetch data from the table: "speaker_type_enum"

  • speaker_type_enum_aggregate: Speaker_Type_Enum_Aggregate

    fetch aggregated fields from the table: "speaker_type_enum"

  • Optional speaker_type_enum_by_pk?: Maybe<Speaker_Type_Enum>

    fetch data from the table: "speaker_type_enum" using primary key columns

  • utterances: Utterances[]

    An array relationship

  • utterances_aggregate: Utterances_Aggregate

    An aggregate relationship

Subscription_RootAppsArgs

Subscription_RootAppsArgs: { distinct_on?: Maybe<Apps_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Apps_Order_By[]>; where?: Maybe<Apps_Bool_Exp> }

Type declaration

Subscription_RootApps_AggregateArgs

Subscription_RootApps_AggregateArgs: { distinct_on?: Maybe<Apps_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Apps_Order_By[]>; where?: Maybe<Apps_Bool_Exp> }

Type declaration

Subscription_RootAtomic_DataArgs

Subscription_RootAtomic_DataArgs: { distinct_on?: Maybe<Atomic_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Atomic_Data_Order_By[]>; where?: Maybe<Atomic_Data_Bool_Exp> }

Type declaration

Subscription_RootAtomic_Data_AggregateArgs

Subscription_RootAtomic_Data_AggregateArgs: { distinct_on?: Maybe<Atomic_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Atomic_Data_Order_By[]>; where?: Maybe<Atomic_Data_Bool_Exp> }

Type declaration

Subscription_RootAudit_Logged_ActionsArgs

Subscription_RootAudit_Logged_ActionsArgs: { distinct_on?: Maybe<Audit_Logged_Actions_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Audit_Logged_Actions_Order_By[]>; where?: Maybe<Audit_Logged_Actions_Bool_Exp> }

Type declaration

Subscription_RootAudit_Logged_Actions_AggregateArgs

Subscription_RootAudit_Logged_Actions_AggregateArgs: { distinct_on?: Maybe<Audit_Logged_Actions_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Audit_Logged_Actions_Order_By[]>; where?: Maybe<Audit_Logged_Actions_Bool_Exp> }

Type declaration

Subscription_RootAudit_Logged_Actions_By_PkArgs

Subscription_RootAudit_Logged_Actions_By_PkArgs: { action_tstamp_stm: Scalars["timestamptz"]; event_id: Scalars["bigint"] }

Type declaration

  • action_tstamp_stm: Scalars["timestamptz"]
  • event_id: Scalars["bigint"]

Subscription_RootConceptnet_DataArgs

Subscription_RootConceptnet_DataArgs: { distinct_on?: Maybe<Conceptnet_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conceptnet_Data_Order_By[]>; where?: Maybe<Conceptnet_Data_Bool_Exp> }

Type declaration

Subscription_RootConceptnet_Data_AggregateArgs

Subscription_RootConceptnet_Data_AggregateArgs: { distinct_on?: Maybe<Conceptnet_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conceptnet_Data_Order_By[]>; where?: Maybe<Conceptnet_Data_Bool_Exp> }

Type declaration

Subscription_RootConceptnet_Search_RelationsArgs

Subscription_RootConceptnet_Search_RelationsArgs: { args: Conceptnet_Search_Relations_Args; distinct_on?: Maybe<Conceptnet_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conceptnet_Data_Order_By[]>; where?: Maybe<Conceptnet_Data_Bool_Exp> }

Type declaration

Subscription_RootConceptnet_Search_Relations_AggregateArgs

Subscription_RootConceptnet_Search_Relations_AggregateArgs: { args: Conceptnet_Search_Relations_Args; distinct_on?: Maybe<Conceptnet_Data_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conceptnet_Data_Order_By[]>; where?: Maybe<Conceptnet_Data_Bool_Exp> }

Type declaration

Subscription_RootConversationsArgs

Subscription_RootConversationsArgs: { distinct_on?: Maybe<Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conversations_Order_By[]>; where?: Maybe<Conversations_Bool_Exp> }

Type declaration

Subscription_RootConversations_AggregateArgs

Subscription_RootConversations_AggregateArgs: { distinct_on?: Maybe<Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Conversations_Order_By[]>; where?: Maybe<Conversations_Bool_Exp> }

Type declaration

Subscription_RootDevelopersArgs

Subscription_RootDevelopersArgs: { distinct_on?: Maybe<Developers_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Developers_Order_By[]>; where?: Maybe<Developers_Bool_Exp> }

Type declaration

Subscription_RootDevelopers_AggregateArgs

Subscription_RootDevelopers_AggregateArgs: { distinct_on?: Maybe<Developers_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Developers_Order_By[]>; where?: Maybe<Developers_Bool_Exp> }

Type declaration

Subscription_RootEnd_User_ConversationsArgs

Subscription_RootEnd_User_ConversationsArgs: { distinct_on?: Maybe<End_User_Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_User_Conversations_Order_By[]>; where?: Maybe<End_User_Conversations_Bool_Exp> }

Type declaration

Subscription_RootEnd_User_Conversations_AggregateArgs

Subscription_RootEnd_User_Conversations_AggregateArgs: { distinct_on?: Maybe<End_User_Conversations_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_User_Conversations_Order_By[]>; where?: Maybe<End_User_Conversations_Bool_Exp> }

Type declaration

Subscription_RootEnd_User_Conversations_By_PkArgs

Subscription_RootEnd_User_Conversations_By_PkArgs: { conversation_id: Scalars["Int"]; end_user_id: Scalars["Int"] }

Type declaration

Subscription_RootEnd_UsersArgs

Subscription_RootEnd_UsersArgs: { distinct_on?: Maybe<End_Users_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_Users_Order_By[]>; where?: Maybe<End_Users_Bool_Exp> }

Type declaration

Subscription_RootEnd_Users_AggregateArgs

Subscription_RootEnd_Users_AggregateArgs: { distinct_on?: Maybe<End_Users_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<End_Users_Order_By[]>; where?: Maybe<End_Users_Bool_Exp> }

Type declaration

Subscription_RootEventsArgs

Subscription_RootEventsArgs: { distinct_on?: Maybe<Events_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Events_Order_By[]>; where?: Maybe<Events_Bool_Exp> }

Type declaration

Subscription_RootEvents_AggregateArgs

Subscription_RootEvents_AggregateArgs: { distinct_on?: Maybe<Events_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Events_Order_By[]>; where?: Maybe<Events_Bool_Exp> }

Type declaration

Subscription_RootHistoryArgs

Subscription_RootHistoryArgs: { distinct_on?: Maybe<History_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<History_Order_By[]>; where?: Maybe<History_Bool_Exp> }

Type declaration

Subscription_RootHistory_AggregateArgs

Subscription_RootHistory_AggregateArgs: { distinct_on?: Maybe<History_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<History_Order_By[]>; where?: Maybe<History_Bool_Exp> }

Type declaration

Subscription_RootKv_Scope_EnumArgs

Subscription_RootKv_Scope_EnumArgs: { distinct_on?: Maybe<Kv_Scope_Enum_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Scope_Enum_Order_By[]>; where?: Maybe<Kv_Scope_Enum_Bool_Exp> }

Type declaration

Subscription_RootKv_Scope_Enum_AggregateArgs

Subscription_RootKv_Scope_Enum_AggregateArgs: { distinct_on?: Maybe<Kv_Scope_Enum_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Scope_Enum_Order_By[]>; where?: Maybe<Kv_Scope_Enum_Bool_Exp> }

Type declaration

Subscription_RootKv_Scope_Enum_By_PkArgs

Subscription_RootKv_Scope_Enum_By_PkArgs: { value: Scalars["String"] }

Type declaration

Subscription_RootKv_StoreArgs

Subscription_RootKv_StoreArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

Type declaration

Subscription_RootKv_Store_AggregateArgs

Subscription_RootKv_Store_AggregateArgs: { distinct_on?: Maybe<Kv_Store_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Kv_Store_Order_By[]>; where?: Maybe<Kv_Store_Bool_Exp> }

Type declaration

Subscription_RootKv_Store_By_PkArgs

Subscription_RootKv_Store_By_PkArgs: { key: Scalars["String"]; scope: Scalars["String"]; scope_object_id: Scalars["Int"] }

Type declaration

Subscription_RootLast_UtteranceArgs

Subscription_RootLast_UtteranceArgs: { distinct_on?: Maybe<Last_Utterance_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Last_Utterance_Order_By[]>; where?: Maybe<Last_Utterance_Bool_Exp> }

Type declaration

Subscription_RootLast_Utterance_AggregateArgs

Subscription_RootLast_Utterance_AggregateArgs: { distinct_on?: Maybe<Last_Utterance_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Last_Utterance_Order_By[]>; where?: Maybe<Last_Utterance_Bool_Exp> }

Type declaration

Subscription_RootMeArgs

Subscription_RootMeArgs: { distinct_on?: Maybe<Developers_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Developers_Order_By[]>; where?: Maybe<Developers_Bool_Exp> }

Type declaration

Subscription_RootMe_AggregateArgs

Subscription_RootMe_AggregateArgs: { distinct_on?: Maybe<Developers_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Developers_Order_By[]>; where?: Maybe<Developers_Bool_Exp> }

Type declaration

Subscription_RootObjectsArgs

Subscription_RootObjectsArgs: { distinct_on?: Maybe<Objects_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Objects_Order_By[]>; where?: Maybe<Objects_Bool_Exp> }

Type declaration

Subscription_RootObjects_AggregateArgs

Subscription_RootObjects_AggregateArgs: { distinct_on?: Maybe<Objects_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Objects_Order_By[]>; where?: Maybe<Objects_Bool_Exp> }

Type declaration

Subscription_RootObjects_By_PkArgs

Subscription_RootObjects_By_PkArgs: { object_id: Scalars["Int"] }

Type declaration

Subscription_RootSpeaker_Type_EnumArgs

Subscription_RootSpeaker_Type_EnumArgs: { distinct_on?: Maybe<Speaker_Type_Enum_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Speaker_Type_Enum_Order_By[]>; where?: Maybe<Speaker_Type_Enum_Bool_Exp> }

Type declaration

Subscription_RootSpeaker_Type_Enum_AggregateArgs

Subscription_RootSpeaker_Type_Enum_AggregateArgs: { distinct_on?: Maybe<Speaker_Type_Enum_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Speaker_Type_Enum_Order_By[]>; where?: Maybe<Speaker_Type_Enum_Bool_Exp> }

Type declaration

Subscription_RootSpeaker_Type_Enum_By_PkArgs

Subscription_RootSpeaker_Type_Enum_By_PkArgs: { value: Scalars["String"] }

Type declaration

Subscription_RootUtterancesArgs

Subscription_RootUtterancesArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

Type declaration

Subscription_RootUtterances_AggregateArgs

Subscription_RootUtterances_AggregateArgs: { distinct_on?: Maybe<Utterances_Select_Column[]>; limit?: Maybe<Scalars["Int"]>; offset?: Maybe<Scalars["Int"]>; order_by?: Maybe<Utterances_Order_By[]>; where?: Maybe<Utterances_Bool_Exp> }

Type declaration

SubtreeFieldsFragment

SubtreeFieldsFragment: { __typename?: "NLUToken" } & Pick<NluToken, "dependency" | "entity_type" | "lemma" | "normalized" | "part_of_speech" | "tag">

SubtreeFragment

SubtreeFragment: { __typename?: "NLUSpan" } & { subtree?: Maybe<Maybe<{ __typename?: "NLUToken" } & { subtree?: Maybe<Maybe<{ __typename?: "NLUToken" } & { subtree?: Maybe<Maybe<{ __typename?: "NLUToken" } & { subtree?: Maybe<Maybe<{ __typename?: "NLUToken" } & SubtreeFieldsFragment>[]> } & SubtreeFieldsFragment>[]> } & SubtreeFieldsFragment>[]> } & SubtreeFieldsFragment>[]> }

TextToSpeechQuery

TextToSpeechQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "TTSResult" } & { audioBase64: TtsResult["result"] }> }

TextToSpeechQueryVariables

TextToSpeechQueryVariables: Exact<{ input: Scalars["String"] }>

Timestamptz_Comparison_Exp

Timestamptz_Comparison_Exp: { _eq?: Maybe<Scalars["timestamptz"]>; _gt?: Maybe<Scalars["timestamptz"]>; _gte?: Maybe<Scalars["timestamptz"]>; _in?: Maybe<Scalars["timestamptz"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["timestamptz"]>; _lte?: Maybe<Scalars["timestamptz"]>; _neq?: Maybe<Scalars["timestamptz"]>; _nin?: Maybe<Scalars["timestamptz"][]> }

Boolean expression to compare columns of type "timestamptz". All fields are combined with logical 'AND'.

Type declaration

ToVecQuery

ToVecQuery: { __typename?: "query_root" } & { result?: Maybe<{ __typename?: "NLUResult" } & { entities?: Maybe<Maybe<{ __typename?: "NLUSpan" } & EntitySubtreeFragment>[]>; noun_chunks?: Maybe<Maybe<{ __typename?: "NLUSpan" } & EntitySubtreeFragment>[]>; sentences?: Maybe<Maybe<{ __typename?: "NLUSpan" } & EntitySubtreeFragment>[]> } & EntityResultFieldsFragment> }

ToVecQueryVariables

ToVecQueryVariables: Exact<{ input: Scalars["String"] }>

Token

Token: Container & { __typename?: "Token"; ancestors?: Maybe<Maybe<Token>[]>; children?: Maybe<Maybe<Token>[]>; cluster?: Maybe<Scalars["Int"]>; conjuncts?: Maybe<Maybe<Token>[]>; dep?: Maybe<Scalars["String"]>; end?: Maybe<Scalars["Int"]>; ent_iob?: Maybe<Scalars["String"]>; ent_type?: Maybe<Scalars["String"]>; extension?: Maybe<TokenExtension>; has_vector?: Maybe<Scalars["Boolean"]>; head?: Maybe<Token>; id?: Maybe<Scalars["Int"]>; is_alpha?: Maybe<Scalars["Boolean"]>; is_ascii?: Maybe<Scalars["Boolean"]>; is_bracket?: Maybe<Scalars["Boolean"]>; is_currency?: Maybe<Scalars["Boolean"]>; is_digit?: Maybe<Scalars["Boolean"]>; is_left_punct?: Maybe<Scalars["Boolean"]>; is_lower?: Maybe<Scalars["Boolean"]>; is_oov?: Maybe<Scalars["Boolean"]>; is_punct?: Maybe<Scalars["Boolean"]>; is_quote?: Maybe<Scalars["Boolean"]>; is_right_punct?: Maybe<Scalars["Boolean"]>; is_sent_start?: Maybe<Scalars["Boolean"]>; is_space?: Maybe<Scalars["Boolean"]>; is_stop?: Maybe<Scalars["Boolean"]>; is_title?: Maybe<Scalars["Boolean"]>; is_upper?: Maybe<Scalars["Boolean"]>; lang?: Maybe<Scalars["String"]>; left_edge?: Maybe<Token>; lefts?: Maybe<Maybe<Token>[]>; lemma?: Maybe<Scalars["String"]>; like_email?: Maybe<Scalars["Boolean"]>; like_num?: Maybe<Scalars["Boolean"]>; like_url?: Maybe<Scalars["Boolean"]>; lower?: Maybe<Scalars["String"]>; norm?: Maybe<Scalars["String"]>; orth?: Maybe<Scalars["String"]>; pos?: Maybe<Scalars["String"]>; prefix?: Maybe<Scalars["String"]>; prob?: Maybe<Scalars["Float"]>; right_edge?: Maybe<Token>; rights?: Maybe<Maybe<Token>[]>; shape?: Maybe<Scalars["String"]>; start?: Maybe<Scalars["Int"]>; subtree?: Maybe<Maybe<Token>[]>; suffix?: Maybe<Scalars["String"]>; tag?: Maybe<Scalars["String"]>; text?: Maybe<Scalars["String"]>; text_with_ws?: Maybe<Scalars["String"]>; vector?: Maybe<Maybe<Scalars["Float"]>[]>; vector_norm?: Maybe<Scalars["Float"]>; whitespace?: Maybe<Scalars["String"]> }

An individual token — i.e. a word, punctuation symbol, whitespace, etc.

TokenExtension

TokenExtension: { __typename?: "TokenExtension"; coref_clusters?: Maybe<Maybe<CorefCluster>[]>; in_coref?: Maybe<Scalars["Boolean"]>; is_implicit?: Maybe<Scalars["Boolean"]> }

Type declaration

  • Optional __typename?: "TokenExtension"
  • Optional coref_clusters?: Maybe<Maybe<CorefCluster>[]>

    All the clusters of corefering mentions in the doc

  • Optional in_coref?: Maybe<Scalars["Boolean"]>

    Is the token in coreference?

  • Optional is_implicit?: Maybe<Scalars["Boolean"]>

    Is the token an implicit fused-head?

TokenSubtreeFieldsFragment

TokenSubtreeFieldsFragment: { __typename?: "NLUToken" } & Pick<NluToken, "dependency" | "entity_type" | "is_alpha" | "is_currency" | "is_digit" | "is_oov" | "is_sent_start" | "is_stop" | "is_title" | "lemma" | "like_email" | "like_num" | "like_url" | "part_of_speech" | "log_probability" | "tag" | "text">

TokenSubtreeFragment

TokenSubtreeFragment: { __typename?: "NLUToken" } & { subtree?: Maybe<Maybe<{ __typename?: "NLUToken" } & { subtree?: Maybe<Maybe<{ __typename?: "NLUToken" } & { subtree?: Maybe<Maybe<{ __typename?: "NLUToken" } & { subtree?: Maybe<Maybe<{ __typename?: "NLUToken" } & TokenSubtreeFieldsFragment>[]> } & TokenSubtreeFieldsFragment>[]> } & TokenSubtreeFieldsFragment>[]> } & TokenSubtreeFieldsFragment>[]> } & TokenSubtreeFieldsFragment

TopicScore

TopicScore: { __typename?: "TopicScore"; score: Scalars["Float"]; topic: Scalars["String"] }

Topic scores

Type declaration

  • Optional __typename?: "TopicScore"
  • score: Scalars["Float"]
  • topic: Scalars["String"]

Tstzrange_Comparison_Exp

Tstzrange_Comparison_Exp: { _eq?: Maybe<Scalars["tstzrange"]>; _gt?: Maybe<Scalars["tstzrange"]>; _gte?: Maybe<Scalars["tstzrange"]>; _in?: Maybe<Scalars["tstzrange"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["tstzrange"]>; _lte?: Maybe<Scalars["tstzrange"]>; _neq?: Maybe<Scalars["tstzrange"]>; _nin?: Maybe<Scalars["tstzrange"][]> }

Boolean expression to compare columns of type "tstzrange". All fields are combined with logical 'AND'.

Type declaration

TtsConfig

TtsConfig: { encoding?: Maybe<AudioEncoding>; gender?: Maybe<Scalars["String"]> }

Input config

Type declaration

TtsResult

TtsResult: { __typename?: "TTSResult"; result?: Maybe<Scalars["String"]> }

Output result

Type declaration

  • Optional __typename?: "TTSResult"
  • Optional result?: Maybe<Scalars["String"]>

    Resulting audio as a base64 string

Turn

Turn: { agent?: Maybe<Agent>; said?: Maybe<Scalars["String"]> }

An object representing a single turn by an agent

Type declaration

Utterances

Utterances: { __typename?: "utterances"; conversation: Conversations; conversation_id: Scalars["Int"]; end_user?: Maybe<End_Users>; end_user_id?: Maybe<Scalars["Int"]>; normalized_utterance: Scalars["String"]; speaker_type: Speaker_Type_Enum_Enum; speaker_type_enum: Speaker_Type_Enum; timestamp: Scalars["timestamptz"]; utterance: Scalars["String"] }

columns and relationships of "utterances"

Type declaration

Utterances_Aggregate

Utterances_Aggregate: { __typename?: "utterances_aggregate"; aggregate?: Maybe<Utterances_Aggregate_Fields>; nodes: Utterances[] }

aggregated selection of "utterances"

Type declaration

Utterances_Aggregate_Fields

Utterances_Aggregate_Fields: { __typename?: "utterances_aggregate_fields"; avg?: Maybe<Utterances_Avg_Fields>; count: Scalars["Int"]; max?: Maybe<Utterances_Max_Fields>; min?: Maybe<Utterances_Min_Fields>; stddev?: Maybe<Utterances_Stddev_Fields>; stddev_pop?: Maybe<Utterances_Stddev_Pop_Fields>; stddev_samp?: Maybe<Utterances_Stddev_Samp_Fields>; sum?: Maybe<Utterances_Sum_Fields>; var_pop?: Maybe<Utterances_Var_Pop_Fields>; var_samp?: Maybe<Utterances_Var_Samp_Fields>; variance?: Maybe<Utterances_Variance_Fields> }

aggregate fields of "utterances"

Type declaration

Utterances_Aggregate_FieldsCountArgs

Utterances_Aggregate_FieldsCountArgs: { columns?: Maybe<Utterances_Select_Column[]>; distinct?: Maybe<Scalars["Boolean"]> }

aggregate fields of "utterances"

Type declaration

Utterances_Aggregate_Order_By

order by aggregate values of table "utterances"

Type declaration

Utterances_Arr_Rel_Insert_Input

Utterances_Arr_Rel_Insert_Input: { data: Utterances_Insert_Input[] }

input type for inserting array relation for remote table "utterances"

Type declaration

Utterances_Avg_Fields

Utterances_Avg_Fields: { __typename?: "utterances_avg_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate avg on columns

Type declaration

  • Optional __typename?: "utterances_avg_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

Utterances_Avg_Order_By

Utterances_Avg_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by avg() on columns of table "utterances"

Type declaration

Utterances_Bool_Exp

Utterances_Bool_Exp: { _and?: Maybe<Utterances_Bool_Exp[]>; _not?: Maybe<Utterances_Bool_Exp>; _or?: Maybe<Utterances_Bool_Exp[]>; conversation?: Maybe<Conversations_Bool_Exp>; conversation_id?: Maybe<Int_Comparison_Exp>; end_user?: Maybe<End_Users_Bool_Exp>; end_user_id?: Maybe<Int_Comparison_Exp>; normalized_utterance?: Maybe<String_Comparison_Exp>; speaker_type?: Maybe<Speaker_Type_Enum_Enum_Comparison_Exp>; speaker_type_enum?: Maybe<Speaker_Type_Enum_Bool_Exp>; timestamp?: Maybe<Timestamptz_Comparison_Exp>; utterance?: Maybe<String_Comparison_Exp> }

Boolean expression to filter rows from the table "utterances". All fields are combined with a logical 'AND'.

Type declaration

Utterances_Inc_Input

Utterances_Inc_Input: { conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]> }

input type for incrementing numeric columns in table "utterances"

Type declaration

Utterances_Insert_Input

Utterances_Insert_Input: { conversation?: Maybe<Conversations_Obj_Rel_Insert_Input>; conversation_id?: Maybe<Scalars["Int"]>; end_user?: Maybe<End_Users_Obj_Rel_Insert_Input>; end_user_id?: Maybe<Scalars["Int"]>; normalized_utterance?: Maybe<Scalars["String"]>; speaker_type?: Maybe<Speaker_Type_Enum_Enum>; speaker_type_enum?: Maybe<Speaker_Type_Enum_Obj_Rel_Insert_Input>; timestamp?: Maybe<Scalars["timestamptz"]>; utterance?: Maybe<Scalars["String"]> }

input type for inserting data into table "utterances"

Type declaration

Utterances_Max_Fields

Utterances_Max_Fields: { __typename?: "utterances_max_fields"; conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]>; normalized_utterance?: Maybe<Scalars["String"]>; timestamp?: Maybe<Scalars["timestamptz"]>; utterance?: Maybe<Scalars["String"]> }

aggregate max on columns

Type declaration

Utterances_Max_Order_By

Utterances_Max_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; normalized_utterance?: Maybe<Order_By>; timestamp?: Maybe<Order_By>; utterance?: Maybe<Order_By> }

order by max() on columns of table "utterances"

Type declaration

Utterances_Min_Fields

Utterances_Min_Fields: { __typename?: "utterances_min_fields"; conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]>; normalized_utterance?: Maybe<Scalars["String"]>; timestamp?: Maybe<Scalars["timestamptz"]>; utterance?: Maybe<Scalars["String"]> }

aggregate min on columns

Type declaration

Utterances_Min_Order_By

Utterances_Min_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By>; normalized_utterance?: Maybe<Order_By>; timestamp?: Maybe<Order_By>; utterance?: Maybe<Order_By> }

order by min() on columns of table "utterances"

Type declaration

Utterances_Mutation_Response

Utterances_Mutation_Response: { __typename?: "utterances_mutation_response"; affected_rows: Scalars["Int"]; returning: Utterances[] }

response of any mutation on the table "utterances"

Type declaration

  • Optional __typename?: "utterances_mutation_response"
  • affected_rows: Scalars["Int"]

    number of rows affected by the mutation

  • returning: Utterances[]

    data from the rows affected by the mutation

Utterances_Order_By

Utterances_Order_By: { conversation?: Maybe<Conversations_Order_By>; conversation_id?: Maybe<Order_By>; end_user?: Maybe<End_Users_Order_By>; end_user_id?: Maybe<Order_By>; normalized_utterance?: Maybe<Order_By>; speaker_type?: Maybe<Order_By>; speaker_type_enum?: Maybe<Speaker_Type_Enum_Order_By>; timestamp?: Maybe<Order_By>; utterance?: Maybe<Order_By> }

Ordering options when selecting data from "utterances".

Type declaration

Utterances_Set_Input

Utterances_Set_Input: { conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]>; normalized_utterance?: Maybe<Scalars["String"]>; speaker_type?: Maybe<Speaker_Type_Enum_Enum>; timestamp?: Maybe<Scalars["timestamptz"]>; utterance?: Maybe<Scalars["String"]> }

input type for updating data in table "utterances"

Type declaration

Utterances_Stddev_Fields

Utterances_Stddev_Fields: { __typename?: "utterances_stddev_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate stddev on columns

Type declaration

  • Optional __typename?: "utterances_stddev_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

Utterances_Stddev_Order_By

Utterances_Stddev_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by stddev() on columns of table "utterances"

Type declaration

Utterances_Stddev_Pop_Fields

Utterances_Stddev_Pop_Fields: { __typename?: "utterances_stddev_pop_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate stddev_pop on columns

Type declaration

  • Optional __typename?: "utterances_stddev_pop_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

Utterances_Stddev_Pop_Order_By

Utterances_Stddev_Pop_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by stddev_pop() on columns of table "utterances"

Type declaration

Utterances_Stddev_Samp_Fields

Utterances_Stddev_Samp_Fields: { __typename?: "utterances_stddev_samp_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate stddev_samp on columns

Type declaration

  • Optional __typename?: "utterances_stddev_samp_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

Utterances_Stddev_Samp_Order_By

Utterances_Stddev_Samp_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by stddev_samp() on columns of table "utterances"

Type declaration

Utterances_Sum_Fields

Utterances_Sum_Fields: { __typename?: "utterances_sum_fields"; conversation_id?: Maybe<Scalars["Int"]>; end_user_id?: Maybe<Scalars["Int"]> }

aggregate sum on columns

Type declaration

  • Optional __typename?: "utterances_sum_fields"
  • Optional conversation_id?: Maybe<Scalars["Int"]>
  • Optional end_user_id?: Maybe<Scalars["Int"]>

Utterances_Sum_Order_By

Utterances_Sum_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by sum() on columns of table "utterances"

Type declaration

Utterances_Var_Pop_Fields

Utterances_Var_Pop_Fields: { __typename?: "utterances_var_pop_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate var_pop on columns

Type declaration

  • Optional __typename?: "utterances_var_pop_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

Utterances_Var_Pop_Order_By

Utterances_Var_Pop_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by var_pop() on columns of table "utterances"

Type declaration

Utterances_Var_Samp_Fields

Utterances_Var_Samp_Fields: { __typename?: "utterances_var_samp_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate var_samp on columns

Type declaration

  • Optional __typename?: "utterances_var_samp_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

Utterances_Var_Samp_Order_By

Utterances_Var_Samp_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by var_samp() on columns of table "utterances"

Type declaration

Utterances_Variance_Fields

Utterances_Variance_Fields: { __typename?: "utterances_variance_fields"; conversation_id?: Maybe<Scalars["Float"]>; end_user_id?: Maybe<Scalars["Float"]> }

aggregate variance on columns

Type declaration

  • Optional __typename?: "utterances_variance_fields"
  • Optional conversation_id?: Maybe<Scalars["Float"]>
  • Optional end_user_id?: Maybe<Scalars["Float"]>

Utterances_Variance_Order_By

Utterances_Variance_Order_By: { conversation_id?: Maybe<Order_By>; end_user_id?: Maybe<Order_By> }

order by variance() on columns of table "utterances"

Type declaration

WordMatch

WordMatch: { __typename?: "WordMatch"; explanation?: Maybe<Scalars["String"]>; extracted_word?: Maybe<Scalars["String"]>; match_type?: Maybe<Scalars["String"]>; similarity?: Maybe<Scalars["Float"]>; slot?: Maybe<Scalars["String"]> }

A word match

Type declaration

  • Optional __typename?: "WordMatch"
  • Optional explanation?: Maybe<Scalars["String"]>

    Match explanation

  • Optional extracted_word?: Maybe<Scalars["String"]>

    A word extracted by the match

  • Optional match_type?: Maybe<Scalars["String"]>

    Type of the match

  • Optional similarity?: Maybe<Scalars["Float"]>

    Similarity measure

  • Optional slot?: Maybe<Scalars["String"]>

    Slot filled by the match

_Text_Comparison_Exp

_Text_Comparison_Exp: { _eq?: Maybe<Scalars["_text"]>; _gt?: Maybe<Scalars["_text"]>; _gte?: Maybe<Scalars["_text"]>; _in?: Maybe<Scalars["_text"][]>; _is_null?: Maybe<Scalars["Boolean"]>; _lt?: Maybe<Scalars["_text"]>; _lte?: Maybe<Scalars["_text"]>; _neq?: Maybe<Scalars["_text"]>; _nin?: Maybe<Scalars["_text"][]> }

Boolean expression to compare columns of type "_text". All fields are combined with logical 'AND'.

Type declaration

Generated using TypeDoc