From d653a2b5438a59e6a628048a6d01923b25ad6c29 Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 11:43:05 -0400 Subject: [PATCH 01/11] implement foreach support --- crates/ndc-graphql/src/connector.rs | 62 ++- .../ndc-graphql/src/connector/capabilities.rs | 24 ++ crates/ndc-graphql/src/query_builder.rs | 354 ++++++++---------- crates/ndc-graphql/src/query_builder/error.rs | 2 + ...n_variables.rs => operation_parameters.rs} | 26 +- 5 files changed, 222 insertions(+), 246 deletions(-) create mode 100644 crates/ndc-graphql/src/connector/capabilities.rs rename crates/ndc-graphql/src/query_builder/{operation_variables.rs => operation_parameters.rs} (73%) diff --git a/crates/ndc-graphql/src/connector.rs b/crates/ndc-graphql/src/connector.rs index 974fd40..feaf846 100644 --- a/crates/ndc-graphql/src/connector.rs +++ b/crates/ndc-graphql/src/connector.rs @@ -12,14 +12,13 @@ use ndc_sdk::{ SchemaError, }, json_response::JsonResponse, - models::{ - self, CapabilitiesResponse, LeafCapability, MutationOperationResults, RowFieldValue, RowSet, - }, + models, }; use schema::schema_response; use std::{collections::BTreeMap, mem}; -use tracing::Instrument; -mod schema; +use tracing::{Instrument, Level}; +pub mod capabilities; +pub mod schema; pub mod setup; mod state; @@ -46,26 +45,7 @@ impl Connector for GraphQLConnector { } async fn get_capabilities() -> JsonResponse { - JsonResponse::Value(CapabilitiesResponse { - version: "0.1.4".to_string(), - capabilities: models::Capabilities { - query: models::QueryCapabilities { - aggregates: None, - variables: None, - explain: Some(LeafCapability {}), - nested_fields: models::NestedFieldCapabilities { - aggregates: None, - filter_by: None, - order_by: None, - }, - }, - mutation: models::MutationCapabilities { - transactional: None, - explain: Some(LeafCapability {}), - }, - relationships: None, - }, - }) + JsonResponse::Value(capabilities::capabilities()) } async fn get_schema( @@ -132,6 +112,13 @@ impl Connector for GraphQLConnector { state: &Self::State, request: models::MutationRequest, ) -> Result, MutationError> { + #[cfg(debug_assertions)] + { + // this block only present in debug builds, to avoid leaking sensitive information + let request_string = serde_json::to_string(&request).map_err(MutationError::new)?; + tracing::event!(Level::DEBUG, "Incoming IR" = request_string); + } + let operation = tracing::info_span!("Build Mutation Document", internal.visibility = "user") .in_scope(|| build_mutation_document(&request, configuration))?; @@ -186,7 +173,7 @@ impl Connector for GraphQLConnector { result }; - MutationOperationResults::Procedure { result } + models::MutationOperationResults::Procedure { result } }), }) .collect::, serde_json::Error>>() @@ -208,6 +195,13 @@ impl Connector for GraphQLConnector { state: &Self::State, request: models::QueryRequest, ) -> Result, QueryError> { + #[cfg(debug_assertions)] + { + // this block only present in debug builds, to avoid leaking sensitive information + let request_string = serde_json::to_string(&request).map_err(QueryError::new)?; + tracing::event!(Level::DEBUG, "Incoming IR" = request_string); + } + let operation = tracing::info_span!("Build Query Document", internal.visibility = "user") .in_scope(|| build_query_document(&request, configuration))?; @@ -216,7 +210,7 @@ impl Connector for GraphQLConnector { let execution_span = tracing::info_span!("Execute GraphQL Query", internal.visibility = "user"); - let (headers, response) = execute_graphql::>( + let (headers, response) = execute_graphql::>( &operation.query, operation.variables, &configuration.connection.endpoint, @@ -242,21 +236,23 @@ impl Connector for GraphQLConnector { IndexMap::from_iter(vec![ ( configuration.response.headers_field.to_string(), - RowFieldValue(headers), + models::RowFieldValue(headers), ), ( configuration.response.response_field.to_string(), - RowFieldValue(data), + models::RowFieldValue(data), ), ]) } else { data }; - Ok(JsonResponse::Value(models::QueryResponse(vec![RowSet { - aggregates: None, - rows: Some(vec![row]), - }]))) + Ok(JsonResponse::Value(models::QueryResponse(vec![ + models::RowSet { + aggregates: None, + rows: Some(vec![row]), + }, + ]))) } else { Err(QueryError::new_unprocessable_content( &"No data or errors in response", diff --git a/crates/ndc-graphql/src/connector/capabilities.rs b/crates/ndc-graphql/src/connector/capabilities.rs new file mode 100644 index 0000000..435d776 --- /dev/null +++ b/crates/ndc-graphql/src/connector/capabilities.rs @@ -0,0 +1,24 @@ +use ndc_sdk::models; + +pub fn capabilities() -> models::CapabilitiesResponse { + models::CapabilitiesResponse { + version: "0.1.4".to_string(), + capabilities: models::Capabilities { + query: models::QueryCapabilities { + aggregates: None, + variables: Some(models::LeafCapability {}), + explain: Some(models::LeafCapability {}), + nested_fields: models::NestedFieldCapabilities { + aggregates: None, + filter_by: None, + order_by: None, + }, + }, + mutation: models::MutationCapabilities { + transactional: None, + explain: Some(models::LeafCapability {}), + }, + relationships: None, + }, + } +} diff --git a/crates/ndc-graphql/src/query_builder.rs b/crates/ndc-graphql/src/query_builder.rs index bebe211..22e7de5 100644 --- a/crates/ndc-graphql/src/query_builder.rs +++ b/crates/ndc-graphql/src/query_builder.rs @@ -1,4 +1,4 @@ -use self::{error::QueryBuilderError, operation_variables::OperationVariables}; +use self::{error::QueryBuilderError, operation_parameters::OperationParameters}; use common::{ config::ServerConfig, schema::{ObjectFieldDefinition, TypeDef}, @@ -16,7 +16,7 @@ use ndc_sdk::models::{self, Argument, NestedField}; use std::collections::BTreeMap; pub mod error; -mod operation_variables; +mod operation_parameters; fn pos() -> Pos { Pos { line: 0, column: 0 } @@ -32,7 +32,9 @@ pub fn build_mutation_document( request: &models::MutationRequest, configuration: &ServerConfig, ) -> Result { - let mut variables = OperationVariables::new(); + // mutations don't have variables, so we use an empty set + let dummy_variables = BTreeMap::new(); + let mut parameters = OperationParameters::new(""); let mut request_headers = BTreeMap::new(); let mut items = vec![]; @@ -61,7 +63,7 @@ pub fn build_mutation_document( })?; let (headers, procedure_arguments) = - extract_headers(arguments, map_arg, configuration)?; + extract_headers(arguments, map_arg, configuration, &BTreeMap::new())?; // note: duplicate headers get dropped here // if there are multiple root fields, preset headers get set here once per field, @@ -74,16 +76,18 @@ pub fn build_mutation_document( name, field_arguments( &procedure_arguments, - |v| Ok(v.to_owned()), + map_arg, field_definition, - &mut variables, + &mut parameters, name, - &mutation_type_name, + mutation_type_name, + &dummy_variables, )?, fields, field_definition, - &mut variables, + &mut parameters, configuration, + &dummy_variables, )?; items.push(item); @@ -96,7 +100,7 @@ pub fn build_mutation_document( items, }; - let (values, variable_definitions) = variables.into_variable_definitions(); + let (values, variable_definitions) = parameters.into_parameter_definitions(); let document: Document = Document { definitions: vec![Definition::Operation(OperationDefinition::Mutation( @@ -120,86 +124,137 @@ pub fn build_query_document( request: &models::QueryRequest, configuration: &ServerConfig, ) -> Result { - let mut variables = OperationVariables::new(); - - let (headers, request_arguments) = - extract_headers(&request.arguments, map_query_arg, configuration)?; - - let mut items = vec![]; - let query_type_name = configuration .schema .query_type_name .as_ref() .ok_or(QueryBuilderError::NoQueryType)?; - for (alias, field) in request + let root_field = request .query .fields .as_ref() - .ok_or_else(|| QueryBuilderError::NoRequesQueryFields)? - .iter() - { - let (fields, arguments) = match field { - models::Field::Column { - column, - fields, - arguments, - } if column == "__value" => Ok((fields, arguments)), - models::Field::Column { - column, - fields: _, - arguments: _, - } => Err(QueryBuilderError::NotSupported(format!( - "Expected field with key __value, got {column}" - ))), - models::Field::Relationship { .. } => { - Err(QueryBuilderError::NotSupported("Relationships".to_string())) - } - }?; - - if !arguments.is_empty() { - return Err(QueryBuilderError::Unexpected( - "Functions arguments should be passed to the collection, not the __value field" - .to_string(), - )); - } + .and_then(|fields| fields.get("__value")) + .ok_or_else(|| QueryBuilderError::NoRequesQueryFields)?; - let field_definition = configuration - .schema - .query_fields - .get(&request.collection) - .ok_or_else(|| QueryBuilderError::QueryFieldNotFound { - field: request.collection.to_owned(), - })?; - - let item = selection_set_field( - alias, - &request.collection, - field_arguments( - &request_arguments, - map_arg, - field_definition, - &mut variables, - &request.collection, - &query_type_name, - )?, + let (subfields, arguments) = match root_field { + models::Field::Column { + column, fields, - field_definition, - &mut variables, - configuration, - )?; + arguments, + } if column == "__value" => Ok((fields, arguments)), + models::Field::Column { + column, + fields: _, + arguments: _, + } => Err(QueryBuilderError::NotSupported(format!( + "Expected field with key __value, got {column}" + ))), + models::Field::Relationship { .. } => { + Err(QueryBuilderError::NotSupported("Relationships".to_string())) + } + }?; - items.push(item); + if !arguments.is_empty() { + return Err(QueryBuilderError::Unexpected( + "Functions arguments should be passed to the collection, not the __value field" + .to_string(), + )); } + let root_field_definition = configuration + .schema + .query_fields + .get(&request.collection) + .ok_or_else(|| QueryBuilderError::QueryFieldNotFound { + field: request.collection.to_owned(), + })?; + + let (headers, items, variable_values, variable_definitions) = + if let Some(variables) = &request.variables { + let mut variable_values = BTreeMap::new(); + let mut variable_definitions = vec![]; + let mut items = vec![]; + let mut all_headers = BTreeMap::new(); + + for (index, variables) in variables.iter().enumerate() { + let mut parameters = OperationParameters::new(format!("q{}_", index + 1)); + + let (mut headers, request_arguments) = + extract_headers(&request.arguments, map_query_arg, configuration, variables)?; + + // note: all_headers is a BTreeMap. Duplicate headers will be discarded here, and the last one will be used + all_headers.append(&mut headers); + + let item = selection_set_field( + &format!("q{}__value", index + 1), + &request.collection, + field_arguments( + &request_arguments, + map_arg, + root_field_definition, + &mut parameters, + &request.collection, + query_type_name, + variables, + )?, + subfields, + root_field_definition, + &mut parameters, + configuration, + variables, + )?; + + let (mut values, mut definitions) = parameters.into_parameter_definitions(); + + items.push(item); + + variable_values.append(&mut values); + variable_definitions.append(&mut definitions) + } + + (all_headers, items, variable_values, variable_definitions) + } else { + let mut parameters = OperationParameters::new(""); + // if the query does not have variables, we use an empty set + let dummy_variables = BTreeMap::new(); + + let (headers, request_arguments) = extract_headers( + &request.arguments, + map_query_arg, + configuration, + &dummy_variables, + )?; + + let item = selection_set_field( + "__value", + &request.collection, + field_arguments( + &request_arguments, + map_arg, + root_field_definition, + &mut parameters, + &request.collection, + query_type_name, + &dummy_variables, + )?, + subfields, + root_field_definition, + &mut parameters, + configuration, + &dummy_variables, + )?; + + let (variable_values, variable_definitions) = parameters.into_parameter_definitions(); + + (headers, vec![item], variable_values, variable_definitions) + }; + let selection_set = SelectionSet { span: (pos(), pos()), items, }; - let (values, variable_definitions) = variables.into_variable_definitions(); - let document = Document { definitions: vec![Definition::Operation(OperationDefinition::Query(Query { position: pos(), @@ -212,7 +267,7 @@ pub fn build_query_document( Ok(Operation { query: document.to_string(), - variables: values, + variables: variable_values, headers, }) } @@ -226,9 +281,10 @@ fn extract_headers( arguments: &BTreeMap, map_argument: M, configuration: &ServerConfig, + variables: &BTreeMap, ) -> Result<(Headers, Arguments), QueryBuilderError> where - M: Fn(&A) -> Result, + M: Fn(&A, &BTreeMap) -> Result, { let mut request_arguments = BTreeMap::new(); let mut headers = configuration.connection.headers.clone(); @@ -236,7 +292,7 @@ where let patterns = &configuration.request.forward_headers; for (name, argument) in arguments { - let value = map_argument(argument)?; + let value = map_argument(argument, variables)?; if name == &configuration.request.headers_argument { match value { @@ -280,14 +336,16 @@ where Ok((headers, request_arguments)) } +#[allow(clippy::too_many_arguments)] fn selection_set_field<'a>( alias: &str, field_name: &str, arguments: Vec<(String, Value<'a, String>)>, fields: &Option, field_definition: &ObjectFieldDefinition, - variables: &mut OperationVariables, + parameters: &mut OperationParameters, configuration: &ServerConfig, + variables: &BTreeMap, ) -> Result, QueryBuilderError> { let selection_set = match fields.as_ref().map(underlying_fields) { Some(fields) => { @@ -332,14 +390,16 @@ fn selection_set_field<'a>( arguments, map_query_arg, field_definition, - variables, + parameters, field_name, object_name, + variables, )?, fields, field_definition, - variables, + parameters, configuration, + variables, ) }) .collect::>()?; @@ -371,12 +431,13 @@ fn field_arguments<'a, A, M>( arguments: &BTreeMap, map_argument: M, field_definition: &ObjectFieldDefinition, - variables: &mut OperationVariables, + parameters: &mut OperationParameters, field_name: &str, object_name: &str, + variables: &BTreeMap, ) -> Result)>, QueryBuilderError> where - M: Fn(&A) -> Result, + M: Fn(&A, &BTreeMap) -> Result, { arguments .iter() @@ -391,24 +452,31 @@ where })? .r#type; - let value = map_argument(arg)?; + let value = map_argument(arg, variables)?; - let value = variables.insert(name, value, input_type); + let value = parameters.insert(name, value, input_type); Ok((name.to_owned(), value)) }) .collect() } -fn map_query_arg(argument: &models::Argument) -> Result { +fn map_query_arg( + argument: &models::Argument, + variables: &BTreeMap, +) -> Result { match argument { - Argument::Variable { name: _ } => { - Err(QueryBuilderError::NotSupported("Variables".to_owned())) - } + Argument::Variable { name } => variables + .get(name) + .map(|v| v.to_owned()) + .ok_or_else(|| QueryBuilderError::MissingVariable(name.to_owned())), Argument::Literal { value } => Ok(value.to_owned()), } } -fn map_arg(argument: &serde_json::Value) -> Result { +fn map_arg( + argument: &serde_json::Value, + _variables: &BTreeMap, +) -> Result { Ok(argument.to_owned()) } @@ -418,119 +486,3 @@ fn underlying_fields(nested_field: &NestedField) -> &IndexMap underlying_fields(&arr.fields), } } - -#[cfg(test)] -mod test { - use std::collections::BTreeMap; - - use common::{ - config::{ConnectionConfig, RequestConfig, ResponseConfig, ServerConfig}, - schema::SchemaDefinition, - }; - use graphql_parser; - - use crate::query_builder::build_query_document; - - #[test] - fn process_query_into_expected_graphql_string() -> Result<(), Box> { - let schema_string = r#" - schema { - query: query_root - } - - - scalar Int - - scalar String - - - type query_root { - "fetch data from the table: \"test\" using primary key columns" - test_by_pk(id: Int!): test - } - - "columns and relationships of \"test\"" - type test { - id: Int! - name: String! - } - - "#; - let schema_document = graphql_parser::parse_schema(schema_string)?; - let request_config = RequestConfig { - forward_headers: vec!["Authorization".to_string()], - ..RequestConfig::default() - }; - let response_config = ResponseConfig::default(); - - let schema = SchemaDefinition::new(&schema_document, &request_config, &response_config)?; - let configuration = ServerConfig { - schema, - request: request_config, - response: response_config, - connection: ConnectionConfig { - endpoint: "".to_string(), - headers: BTreeMap::new(), - }, - }; - let request = serde_json::from_value(serde_json::json!({ - "collection": "test_by_pk", - "query": { - "fields": { - "__value": { - "type": "column", - "column": "__value", - "fields": { - "type": "object", - "fields": { - "id": { - "type": "column", - "column": "id", - "fields": null - }, - "name": { - "type": "column", - "column": "name", - "fields": null - } - } - } - } - } - }, - "arguments": { - "_headers": { - "type": "literal", - "value": { - "Authorization": "Bearer" - } - }, - "id": { - "type": "literal", - "value": 1 - } - }, - "collection_relationships": {} - }))?; - - let operation = build_query_document(&request, &configuration)?; - - let expected_query = r#" -query($arg_1_id: Int!) { - __value: test_by_pk(id: $arg_1_id) { - id - name - } -}"#; - let expected_variables = - BTreeMap::from_iter(vec![("arg_1_id".to_string(), serde_json::json!(1))]); - let expected_headers = - BTreeMap::from_iter(vec![("Authorization".to_string(), "Bearer".to_string())]); - - assert_eq!(operation.query.trim(), expected_query.trim()); - assert_eq!(operation.variables, expected_variables); - assert_eq!(operation.headers, expected_headers); - - Ok(()) - } -} diff --git a/crates/ndc-graphql/src/query_builder/error.rs b/crates/ndc-graphql/src/query_builder/error.rs index 2f41ac1..213da84 100644 --- a/crates/ndc-graphql/src/query_builder/error.rs +++ b/crates/ndc-graphql/src/query_builder/error.rs @@ -32,6 +32,7 @@ pub enum QueryBuilderError { }, MisshapenHeadersArgument(serde_json::Value), Unexpected(String), + MissingVariable(String), } impl std::error::Error for QueryBuilderError {} @@ -102,6 +103,7 @@ impl Display for QueryBuilderError { QueryBuilderError::MisshapenHeadersArgument(headers) => { write!(f, "Misshapen headers argument: {}", headers) } + QueryBuilderError::MissingVariable(name) => write!(f, "Missing variable {name}"), } } } diff --git a/crates/ndc-graphql/src/query_builder/operation_variables.rs b/crates/ndc-graphql/src/query_builder/operation_parameters.rs similarity index 73% rename from crates/ndc-graphql/src/query_builder/operation_variables.rs rename to crates/ndc-graphql/src/query_builder/operation_parameters.rs index 4eed393..78a24cf 100644 --- a/crates/ndc-graphql/src/query_builder/operation_variables.rs +++ b/crates/ndc-graphql/src/query_builder/operation_parameters.rs @@ -6,16 +6,18 @@ use graphql_parser::{ Pos, }; -pub struct OperationVariables { - variables: BTreeMap, - variable_index: u32, +pub struct OperationParameters { + namespace: String, + parameters: BTreeMap, + parameter_index: u32, } -impl<'c> OperationVariables { - pub fn new() -> Self { +impl<'c> OperationParameters { + pub fn new>(namespace: S) -> Self { Self { - variables: BTreeMap::new(), - variable_index: 1, + namespace: namespace.into(), + parameters: BTreeMap::new(), + parameter_index: 1, } } pub fn insert( @@ -24,15 +26,15 @@ impl<'c> OperationVariables { value: serde_json::Value, r#type: &TypeRef, ) -> Value<'c, String> { - let name = format!("arg_{}_{}", self.variable_index, name); - self.variable_index += 1; + let name = format!("{}arg_{}_{}", self.namespace, self.parameter_index, name); + self.parameter_index += 1; - self.variables + self.parameters .insert(name.clone(), (value, r#type.to_owned())); Value::Variable(name) } - pub fn into_variable_definitions( + pub fn into_parameter_definitions( self, ) -> ( BTreeMap, @@ -48,7 +50,7 @@ impl<'c> OperationVariables { } } let (values, definitions) = self - .variables + .parameters .into_iter() .map(|(alias, (value, typeref))| { ( From 9f7f7b068583f9c6ac4e5168b78d65d48cea868a Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 11:43:59 -0400 Subject: [PATCH 02/11] change config file defaults, prompt for endpoint env var --- ci/templates/connector-metadata.yaml | 7 +++++-- crates/common/src/config_file.rs | 7 ++----- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/ci/templates/connector-metadata.yaml b/ci/templates/connector-metadata.yaml index c0710d4..6c86eed 100644 --- a/ci/templates/connector-metadata.yaml +++ b/ci/templates/connector-metadata.yaml @@ -2,6 +2,10 @@ packagingDefinition: type: PrebuiltDockerImage dockerImage: "${DOCKER_IMAGE}" supportedEnvironmentVariables: + - name: GRAPHQL_ENDPOINT + description: The GraphQL Endpoint + defaultValue: "" + required: true commands: update: hasura-ndc-graphql update cliPlugin: @@ -11,5 +15,4 @@ dockerComposeWatch: - path: ./ target: /etc/connector action: sync+restart - - +documentationPage: https://hasura.info/graphql-getting-started diff --git a/crates/common/src/config_file.rs b/crates/common/src/config_file.rs index 40d3d24..1a1a15e 100644 --- a/crates/common/src/config_file.rs +++ b/crates/common/src/config_file.rs @@ -42,11 +42,8 @@ pub struct ConnectionConfigFile { impl Default for ConnectionConfigFile { fn default() -> Self { Self { - endpoint: ConfigValue::Value("".to_string()), - headers: BTreeMap::from_iter(vec![( - "Authorization".to_owned(), - ConfigValue::ValueFromEnv("GRAPHQL_ENDPOINT_AUTHORIZATION".to_string()), - )]), + endpoint: ConfigValue::ValueFromEnv("GRAPHQL_ENDPOINT".to_string()), + headers: BTreeMap::new(), } } } From de2b7d4b5c19110de6df342840bd69bc62e08d9a Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 11:44:20 -0400 Subject: [PATCH 03/11] add security audit job --- .github/workflows/security-audit.yaml | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 .github/workflows/security-audit.yaml diff --git a/.github/workflows/security-audit.yaml b/.github/workflows/security-audit.yaml new file mode 100644 index 0000000..f8695b2 --- /dev/null +++ b/.github/workflows/security-audit.yaml @@ -0,0 +1,20 @@ +name: Security audit +on: + pull_request: +jobs: + audit: + name: Security Audit + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions-rust-lang/setup-rust-toolchain@v1 + with: + # this defaults to "-D warnings", making warnings fail the entire build. + # setting to empty strng to allow builds with warnings + # todo: consider removing this, and disallowing pushing with warnings? + rustflags: "" + # we don't use the audit-check action, because it overwrites our lockfile before checking + # ref: https://github.com/rustsec/audit-check/issues/15 + # todo: once that is fixed, move to audit-check, and set up regular audit check on top of these PR ones + - run: cargo install cargo-audit --locked + - run: cargo audit From 1867a6beb73e9705c4614aa60a3600c3c3303ddc Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 14:23:42 -0400 Subject: [PATCH 04/11] bugfix: parse default values, instead of serializing as string --- crates/ndc-graphql-cli/src/graphql.rs | 60 ++++++++++++++++++++++++--- 1 file changed, 54 insertions(+), 6 deletions(-) diff --git a/crates/ndc-graphql-cli/src/graphql.rs b/crates/ndc-graphql-cli/src/graphql.rs index 6ed6493..7e70002 100644 --- a/crates/ndc-graphql-cli/src/graphql.rs +++ b/crates/ndc-graphql-cli/src/graphql.rs @@ -5,7 +5,7 @@ use common::{ config::ConnectionConfig, }; use graphql_parser::{ - query::{Type, Value}, + query::{self, OperationDefinition, Selection, Type, Value}, schema::{ Definition, DirectiveDefinition, DirectiveLocation, Document, EnumType, EnumValue, Field, InputObjectType, InputValue, InterfaceType, ObjectType, ScalarType, SchemaDefinition, @@ -15,7 +15,7 @@ use graphql_parser::{ }; use self::introspection::{InputTypeRef, Introspection, OutputTypeRef}; -mod introspection; +pub mod introspection; pub async fn execute_graphql_introspection( connection: &ConnectionConfig, @@ -107,7 +107,7 @@ pub fn schema_from_introspection(introspection: Introspection) -> Document<'stat description: arg.description, name: arg.name, value_type: input_type(arg.r#type), - default_value: arg.default_value.map(Value::String), + default_value: arg.default_value.map(parse_value), directives: vec![], }) .collect(), @@ -130,7 +130,7 @@ pub fn schema_from_introspection(introspection: Introspection) -> Document<'stat description: field.description, name: field.name, value_type: input_type(field.r#type), - default_value: field.default_value.map(Value::String), + default_value: field.default_value.map(parse_value), directives: vec![], }) .collect(), @@ -159,6 +159,7 @@ pub fn schema_from_introspection(introspection: Introspection) -> Document<'stat name: interface.name, implements_interfaces: interface .interfaces + .unwrap_or_default() .into_iter() .map(|i| i.name) .collect(), @@ -178,7 +179,7 @@ pub fn schema_from_introspection(introspection: Introspection) -> Document<'stat description: arg.description, name: arg.name, value_type: input_type(arg.r#type), - default_value: arg.default_value.map(Value::String), + default_value: arg.default_value.map(parse_value), directives: vec![], }) .collect(), @@ -217,7 +218,7 @@ pub fn schema_from_introspection(introspection: Introspection) -> Document<'stat directives: vec![], }) .collect(), - repeatable: directive.is_repeatable.unwrap_or(false), + repeatable: false, locations: directive .locations .iter() @@ -262,6 +263,53 @@ pub fn schema_from_introspection(introspection: Introspection) -> Document<'stat graphql_parser::schema::Document { definitions } } +fn parse_value(value: String) -> Value<'static, String> { + // to parse a value using graphql parser, we build a dummy query + // this is a hack but it works, and this is not performance critical + let query_string = format!(r#"query {{ field(value: {value}) }}"#); + + // We've just built the query, so we can make some assumptions about the shape of the resulting AST. + // We're also assuming that the value can be parsed successfully. + // Since this is the CLI plugin, we can pannic if our assumptions are incorrect + let document = graphql_parser::parse_query::<'_, String>(&query_string) + .expect("Default value should be a valid graphql value"); + let operation = &document.definitions[0]; + let query = match operation { + query::Definition::Operation(operation) => match operation { + OperationDefinition::Query(query) => query, + _ => panic!("Expected Query Operation Definition"), + }, + _ => panic!("Expected Operation Definition"), + }; + let field = match &query.selection_set.items[0] { + Selection::Field(field) => field, + _ => panic!("Expected field selection"), + }; + let argument = &field.arguments[0]; + let (_name, value) = argument; + + value.into_static().to_owned() +} + +#[test] +fn test_parse_value() { + let values = vec![ + "[ENUM_1, ENUM_2]", + "1.234", + r#""String""#, + r#"{object: "property"}"#, + ]; + + for value in values { + let parsed_value = parse_value(value.to_string()); + assert_eq!( + value, + parsed_value.to_string(), + "GraphQL value {value} should be parsed correctly" + ) + } +} + fn input_type(input: InputTypeRef) -> Type<'static, String> { match input { InputTypeRef::Scalar(named) From 9fbb9f521264b16209f22e5d81249b0b61f0e1b7 Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 14:24:13 -0400 Subject: [PATCH 05/11] remove isRepeatable from introspection --- crates/ndc-graphql-cli/src/graphql/introspection.rs | 3 +-- crates/ndc-graphql-cli/src/graphql/introspection_query.graphql | 1 - 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/crates/ndc-graphql-cli/src/graphql/introspection.rs b/crates/ndc-graphql-cli/src/graphql/introspection.rs index fddcbcd..5588766 100644 --- a/crates/ndc-graphql-cli/src/graphql/introspection.rs +++ b/crates/ndc-graphql-cli/src/graphql/introspection.rs @@ -54,7 +54,6 @@ pub struct Directive { pub description: Option, pub locations: Vec, pub args: Vec, - pub is_repeatable: Option, } #[derive(Debug, Serialize, Deserialize)] @@ -100,7 +99,7 @@ pub struct Interface { pub name: String, pub description: Option, pub fields: Vec, - pub interfaces: Vec, + pub interfaces: Option>, pub possible_types: Vec, } #[derive(Debug, Serialize, Deserialize)] diff --git a/crates/ndc-graphql-cli/src/graphql/introspection_query.graphql b/crates/ndc-graphql-cli/src/graphql/introspection_query.graphql index 370d273..ef67dc5 100644 --- a/crates/ndc-graphql-cli/src/graphql/introspection_query.graphql +++ b/crates/ndc-graphql-cli/src/graphql/introspection_query.graphql @@ -19,7 +19,6 @@ query IntrospectionQuery { args { ...InputValue } - isRepeatable } } } From f409dbf3cbe4e3216c28d6aa343930c310ac43ad Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 14:28:27 -0400 Subject: [PATCH 06/11] add query builder tests --- crates/ndc-graphql/src/connector/setup.rs | 2 +- .../config-1/configuration/configuration.json | 25 + .../configuration/configuration.schema.json | 168 + .../config-1/configuration/schema.graphql | 3740 ++++ .../01_single_operation.request.json | 33 + .../02_multiple_operations.request.json | 59 + .../mutations/_mutation_request.schema.json | 989 + .../queries/01_basic_query.request.json | 97 + .../02_root_node_parameters.request.json | 110 + .../03_child_node_parameters.request.json | 116 + .../config-1/queries/04_foreach.request.json | 112 + .../queries/_query_request.schema.json | 974 + .../config-2/configuration/configuration.json | 29 + .../configuration/configuration.schema.json | 168 + .../config-2/configuration/schema.graphql | 3740 ++++ .../01_single_operation.request.json | 36 + .../02_multiple_operations.request.json | 62 + .../mutations/_mutation_request.schema.json | 989 + .../queries/01_basic_query.request.json | 104 + .../02_root_node_parameters.request.json | 116 + .../03_child_node_parameters.request.json | 122 + .../config-2/queries/04_foreach.request.json | 125 + .../queries/_query_request.schema.json | 974 + .../config-3/configuration/configuration.json | 30 + .../configuration/configuration.schema.json | 168 + .../config-3/configuration/schema.graphql | 3740 ++++ .../01_single_operation.request.json | 36 + .../02_multiple_operations.request.json | 62 + .../mutations/_mutation_request.schema.json | 989 + .../queries/01_basic_query.request.json | 104 + .../02_root_node_parameters.request.json | 116 + .../03_child_node_parameters.request.json | 122 + .../config-3/queries/04_foreach.request.json | 125 + .../queries/_query_request.schema.json | 974 + crates/ndc-graphql/tests/query_builder.rs | 109 + .../query_builder__Capabilities.snap | 12 + ...__Headers@01_basic_query.request.json.snap | 6 + ...ders@01_single_operation.request.json.snap | 6 + ...s@02_multiple_operations.request.json.snap | 6 + ...@02_root_node_parameters.request.json.snap | 6 + ...03_child_node_parameters.request.json.snap | 6 + ...lder__Headers@04_foreach.request.json.snap | 6 + ...ry String@01_basic_query.request.json.snap | 24 + ...ring@01_single_operation.request.json.snap | 11 + ...g@02_multiple_operations.request.json.snap | 15 + ...@02_root_node_parameters.request.json.snap | 24 + ...03_child_node_parameters.request.json.snap | 24 + ..._Query String@04_foreach.request.json.snap | 46 + ...Variables@01_basic_query.request.json.snap | 6 + ...bles@01_single_operation.request.json.snap | 13 + ...s@02_multiple_operations.request.json.snap | 19 + ...@02_root_node_parameters.request.json.snap | 13 + ...03_child_node_parameters.request.json.snap | 14 + ...er__Variables@04_foreach.request.json.snap | 25 + .../query_builder__config-1 NDC Schema.snap | 16235 ++++++++++++++ .../query_builder__config-2 NDC Schema.snap | 17890 ++++++++++++++++ .../query_builder__config-3 NDC Schema.snap | 17890 ++++++++++++++++ 57 files changed, 71761 insertions(+), 1 deletion(-) create mode 100644 crates/ndc-graphql/tests/config-1/configuration/configuration.json create mode 100644 crates/ndc-graphql/tests/config-1/configuration/configuration.schema.json create mode 100644 crates/ndc-graphql/tests/config-1/configuration/schema.graphql create mode 100644 crates/ndc-graphql/tests/config-1/mutations/01_single_operation.request.json create mode 100644 crates/ndc-graphql/tests/config-1/mutations/02_multiple_operations.request.json create mode 100644 crates/ndc-graphql/tests/config-1/mutations/_mutation_request.schema.json create mode 100644 crates/ndc-graphql/tests/config-1/queries/01_basic_query.request.json create mode 100644 crates/ndc-graphql/tests/config-1/queries/02_root_node_parameters.request.json create mode 100644 crates/ndc-graphql/tests/config-1/queries/03_child_node_parameters.request.json create mode 100644 crates/ndc-graphql/tests/config-1/queries/04_foreach.request.json create mode 100644 crates/ndc-graphql/tests/config-1/queries/_query_request.schema.json create mode 100644 crates/ndc-graphql/tests/config-2/configuration/configuration.json create mode 100644 crates/ndc-graphql/tests/config-2/configuration/configuration.schema.json create mode 100644 crates/ndc-graphql/tests/config-2/configuration/schema.graphql create mode 100644 crates/ndc-graphql/tests/config-2/mutations/01_single_operation.request.json create mode 100644 crates/ndc-graphql/tests/config-2/mutations/02_multiple_operations.request.json create mode 100644 crates/ndc-graphql/tests/config-2/mutations/_mutation_request.schema.json create mode 100644 crates/ndc-graphql/tests/config-2/queries/01_basic_query.request.json create mode 100644 crates/ndc-graphql/tests/config-2/queries/02_root_node_parameters.request.json create mode 100644 crates/ndc-graphql/tests/config-2/queries/03_child_node_parameters.request.json create mode 100644 crates/ndc-graphql/tests/config-2/queries/04_foreach.request.json create mode 100644 crates/ndc-graphql/tests/config-2/queries/_query_request.schema.json create mode 100644 crates/ndc-graphql/tests/config-3/configuration/configuration.json create mode 100644 crates/ndc-graphql/tests/config-3/configuration/configuration.schema.json create mode 100644 crates/ndc-graphql/tests/config-3/configuration/schema.graphql create mode 100644 crates/ndc-graphql/tests/config-3/mutations/01_single_operation.request.json create mode 100644 crates/ndc-graphql/tests/config-3/mutations/02_multiple_operations.request.json create mode 100644 crates/ndc-graphql/tests/config-3/mutations/_mutation_request.schema.json create mode 100644 crates/ndc-graphql/tests/config-3/queries/01_basic_query.request.json create mode 100644 crates/ndc-graphql/tests/config-3/queries/02_root_node_parameters.request.json create mode 100644 crates/ndc-graphql/tests/config-3/queries/03_child_node_parameters.request.json create mode 100644 crates/ndc-graphql/tests/config-3/queries/04_foreach.request.json create mode 100644 crates/ndc-graphql/tests/config-3/queries/_query_request.schema.json create mode 100644 crates/ndc-graphql/tests/query_builder.rs create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Capabilities.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Headers@01_basic_query.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Headers@01_single_operation.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Headers@02_multiple_operations.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Headers@02_root_node_parameters.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Headers@03_child_node_parameters.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Headers@04_foreach.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Query String@01_basic_query.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Query String@01_single_operation.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Query String@02_multiple_operations.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Query String@02_root_node_parameters.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Query String@03_child_node_parameters.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Query String@04_foreach.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Variables@01_basic_query.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Variables@01_single_operation.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Variables@02_multiple_operations.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Variables@02_root_node_parameters.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Variables@03_child_node_parameters.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__Variables@04_foreach.request.json.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__config-1 NDC Schema.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__config-2 NDC Schema.snap create mode 100644 crates/ndc-graphql/tests/snapshots/query_builder__config-3 NDC Schema.snap diff --git a/crates/ndc-graphql/src/connector/setup.rs b/crates/ndc-graphql/src/connector/setup.rs index 605b992..2689c36 100644 --- a/crates/ndc-graphql/src/connector/setup.rs +++ b/crates/ndc-graphql/src/connector/setup.rs @@ -54,7 +54,7 @@ impl GraphQLConnectorSetup { pub fn new(environment: HashMap) -> Self { Self { environment } } - async fn read_configuration( + pub async fn read_configuration( &self, configuration_dir: impl AsRef + Send, ) -> Result { diff --git a/crates/ndc-graphql/tests/config-1/configuration/configuration.json b/crates/ndc-graphql/tests/config-1/configuration/configuration.json new file mode 100644 index 0000000..6a25d5a --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/configuration/configuration.json @@ -0,0 +1,25 @@ +{ + "$schema": "configuration.schema.json", + "introspection": { + "endpoint": { + "valueFromEnv": "GRAPHQL_ENDPOINT" + }, + "headers": { + "x-hasura-admin-secret": { + "valueFromEnv": "GRAPHQL_ENDPOINT_SECRET" + } + } + }, + "execution": { + "endpoint": { + "valueFromEnv": "GRAPHQL_ENDPOINT" + }, + "headers": { + "Authorization": { + "value": "Bearer " + } + } + }, + "request": {}, + "response": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-1/configuration/configuration.schema.json b/crates/ndc-graphql/tests/config-1/configuration/configuration.schema.json new file mode 100644 index 0000000..88c1025 --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/configuration/configuration.schema.json @@ -0,0 +1,168 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "ServerConfigFile", + "type": "object", + "required": [ + "$schema", + "execution", + "introspection", + "request", + "response" + ], + "properties": { + "$schema": { + "type": "string" + }, + "introspection": { + "description": "Connection Configuration for introspection", + "allOf": [ + { + "$ref": "#/definitions/ConnectionConfigFile" + } + ] + }, + "execution": { + "description": "Connection configuration for query execution", + "allOf": [ + { + "$ref": "#/definitions/ConnectionConfigFile" + } + ] + }, + "request": { + "description": "Optional configuration for requests", + "allOf": [ + { + "$ref": "#/definitions/RequestConfigFile" + } + ] + }, + "response": { + "description": "Optional configuration for responses", + "allOf": [ + { + "$ref": "#/definitions/ResponseConfigFile" + } + ] + } + }, + "definitions": { + "ConnectionConfigFile": { + "type": "object", + "required": [ + "endpoint" + ], + "properties": { + "endpoint": { + "$ref": "#/definitions/ConfigValue" + }, + "headers": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/ConfigValue" + } + } + } + }, + "ConfigValue": { + "oneOf": [ + { + "type": "object", + "required": [ + "value" + ], + "properties": { + "value": { + "type": "string" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "valueFromEnv" + ], + "properties": { + "valueFromEnv": { + "type": "string" + } + }, + "additionalProperties": false + } + ] + }, + "RequestConfigFile": { + "type": "object", + "properties": { + "headersArgument": { + "description": "Name of the headers argument Must not conflict with any arguments of root fields in the target schema Defaults to \"_headers\", set to a different value if there is a conflict", + "type": [ + "string", + "null" + ] + }, + "headersTypeName": { + "description": "Name of the headers argument type Must not conflict with other types in the target schema Defaults to \"_HeaderMap\", set to a different value if there is a conflict", + "type": [ + "string", + "null" + ] + }, + "forwardHeaders": { + "description": "List of headers to from the request Defaults to [], AKA no headers/disabled Supports glob patterns eg. \"X-Hasura-*\" Enabling this requires additional configuration on the ddn side, see docs for more", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + }, + "ResponseConfigFile": { + "type": "object", + "properties": { + "headersField": { + "description": "Name of the headers field in the response type Defaults to \"headers\"", + "type": [ + "string", + "null" + ] + }, + "responseField": { + "description": "Name of the response field in the response type Defaults to \"response\"", + "type": [ + "string", + "null" + ] + }, + "typeNamePrefix": { + "description": "Prefix for response type names Defaults to \"_\" Generated response type names must be unique once prefix and suffix are applied", + "type": [ + "string", + "null" + ] + }, + "typeNameSuffix": { + "description": "Suffix for response type names Defaults to \"Response\" Generated response type names must be unique once prefix and suffix are applied", + "type": [ + "string", + "null" + ] + }, + "forwardHeaders": { + "description": "List of headers to from the response Defaults to [], AKA no headers/disabled Supports glob patterns eg. \"X-Hasura-*\" Enabling this requires additional configuration on the ddn side, see docs for more", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-1/configuration/schema.graphql b/crates/ndc-graphql/tests/config-1/configuration/schema.graphql new file mode 100644 index 0000000..d301e54 --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/configuration/schema.graphql @@ -0,0 +1,3740 @@ +schema { + query: query_root + mutation: mutation_root +} + +"columns and relationships of \"Album\"" +type Album { + AlbumId: Int! + "An object relationship" + Artist: Artist! + ArtistId: Int! + Title: String! + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"Album\"" +type Album_aggregate { + aggregate: Album_aggregate_fields + nodes: [Album!]! +} + +input Album_aggregate_bool_exp { + count: Album_aggregate_bool_exp_count +} + +input Album_aggregate_bool_exp_count { + arguments: [Album_select_column!] + distinct: Boolean + filter: Album_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Album\"" +type Album_aggregate_fields { + avg: Album_avg_fields + count(columns: [Album_select_column!], distinct: Boolean): Int! + max: Album_max_fields + min: Album_min_fields + stddev: Album_stddev_fields + stddev_pop: Album_stddev_pop_fields + stddev_samp: Album_stddev_samp_fields + sum: Album_sum_fields + var_pop: Album_var_pop_fields + var_samp: Album_var_samp_fields + variance: Album_variance_fields +} + +"order by aggregate values of table \"Album\"" +input Album_aggregate_order_by { + avg: Album_avg_order_by + count: order_by + max: Album_max_order_by + min: Album_min_order_by + stddev: Album_stddev_order_by + stddev_pop: Album_stddev_pop_order_by + stddev_samp: Album_stddev_samp_order_by + sum: Album_sum_order_by + var_pop: Album_var_pop_order_by + var_samp: Album_var_samp_order_by + variance: Album_variance_order_by +} + +"input type for inserting array relation for remote table \"Album\"" +input Album_arr_rel_insert_input { + data: [Album_insert_input!]! + "upsert condition" on_conflict: Album_on_conflict +} + +"aggregate avg on columns" +type Album_avg_fields { + AlbumId: Float + ArtistId: Float +} + +"order by avg() on columns of table \"Album\"" +input Album_avg_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"Boolean expression to filter rows from the table \"Album\". All fields are combined with a logical 'AND'." +input Album_bool_exp { + AlbumId: Int_comparison_exp + Artist: Artist_bool_exp + ArtistId: Int_comparison_exp + Title: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [Album_bool_exp!] + _not: Album_bool_exp + _or: [Album_bool_exp!] +} + +"unique or primary key constraints on table \"Album\"" +enum Album_constraint { + "unique or primary key constraint on columns \"AlbumId\"" PK_Album +} + +"input type for incrementing numeric columns in table \"Album\"" +input Album_inc_input { + ArtistId: Int +} + +"input type for inserting data into table \"Album\"" +input Album_insert_input { + Artist: Artist_obj_rel_insert_input + ArtistId: Int + Title: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type Album_max_fields { + AlbumId: Int + ArtistId: Int + Title: String +} + +"order by max() on columns of table \"Album\"" +input Album_max_order_by { + AlbumId: order_by + ArtistId: order_by + Title: order_by +} + +"aggregate min on columns" +type Album_min_fields { + AlbumId: Int + ArtistId: Int + Title: String +} + +"order by min() on columns of table \"Album\"" +input Album_min_order_by { + AlbumId: order_by + ArtistId: order_by + Title: order_by +} + +"response of any mutation on the table \"Album\"" +type Album_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Album!]! +} + +"input type for inserting object relation for remote table \"Album\"" +input Album_obj_rel_insert_input { + data: Album_insert_input! + "upsert condition" on_conflict: Album_on_conflict +} + +"on_conflict condition type for table \"Album\"" +input Album_on_conflict { + constraint: Album_constraint! + update_columns: [Album_update_column!]! = [] + where: Album_bool_exp +} + +"Ordering options when selecting data from \"Album\"." +input Album_order_by { + AlbumId: order_by + Artist: Artist_order_by + ArtistId: order_by + Title: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: Album" +input Album_pk_columns_input { + AlbumId: Int! +} + +"select columns of table \"Album\"" +enum Album_select_column { + "column name" AlbumId + "column name" ArtistId + "column name" Title +} + +"input type for updating data in table \"Album\"" +input Album_set_input { + ArtistId: Int + Title: String +} + +"aggregate stddev on columns" +type Album_stddev_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev() on columns of table \"Album\"" +input Album_stddev_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate stddev_pop on columns" +type Album_stddev_pop_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev_pop() on columns of table \"Album\"" +input Album_stddev_pop_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate stddev_samp on columns" +type Album_stddev_samp_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev_samp() on columns of table \"Album\"" +input Album_stddev_samp_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"Streaming cursor of the table \"Album\"" +input Album_stream_cursor_input { + "Stream column input with initial value" initial_value: Album_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Album_stream_cursor_value_input { + AlbumId: Int + ArtistId: Int + Title: String +} + +"aggregate sum on columns" +type Album_sum_fields { + AlbumId: Int + ArtistId: Int +} + +"order by sum() on columns of table \"Album\"" +input Album_sum_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"update columns of table \"Album\"" +enum Album_update_column { + "column name" ArtistId + "column name" Title +} + +input Album_updates { + "increments the numeric columns with given value of the filtered values" _inc: Album_inc_input + "sets the columns of the filtered rows to the given values" _set: Album_set_input + "filter the rows which have to be updated" where: Album_bool_exp! +} + +"aggregate var_pop on columns" +type Album_var_pop_fields { + AlbumId: Float + ArtistId: Float +} + +"order by var_pop() on columns of table \"Album\"" +input Album_var_pop_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate var_samp on columns" +type Album_var_samp_fields { + AlbumId: Float + ArtistId: Float +} + +"order by var_samp() on columns of table \"Album\"" +input Album_var_samp_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate variance on columns" +type Album_variance_fields { + AlbumId: Float + ArtistId: Float +} + +"order by variance() on columns of table \"Album\"" +input Album_variance_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"columns and relationships of \"Artist\"" +type Artist { + "An array relationship" + Albums("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "An aggregate relationship" + Albums_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + ArtistId: Int! + Name: String +} + +"aggregated selection of \"Artist\"" +type Artist_aggregate { + aggregate: Artist_aggregate_fields + nodes: [Artist!]! +} + +"aggregate fields of \"Artist\"" +type Artist_aggregate_fields { + avg: Artist_avg_fields + count(columns: [Artist_select_column!], distinct: Boolean): Int! + max: Artist_max_fields + min: Artist_min_fields + stddev: Artist_stddev_fields + stddev_pop: Artist_stddev_pop_fields + stddev_samp: Artist_stddev_samp_fields + sum: Artist_sum_fields + var_pop: Artist_var_pop_fields + var_samp: Artist_var_samp_fields + variance: Artist_variance_fields +} + +"aggregate avg on columns" +type Artist_avg_fields { + ArtistId: Float +} + +"Boolean expression to filter rows from the table \"Artist\". All fields are combined with a logical 'AND'." +input Artist_bool_exp { + Albums: Album_bool_exp + Albums_aggregate: Album_aggregate_bool_exp + ArtistId: Int_comparison_exp + Name: String_comparison_exp + _and: [Artist_bool_exp!] + _not: Artist_bool_exp + _or: [Artist_bool_exp!] +} + +"unique or primary key constraints on table \"Artist\"" +enum Artist_constraint { + "unique or primary key constraint on columns \"ArtistId\"" PK_Artist +} + +"input type for inserting data into table \"Artist\"" +input Artist_insert_input { + Albums: Album_arr_rel_insert_input + Name: String +} + +"aggregate max on columns" +type Artist_max_fields { + ArtistId: Int + Name: String +} + +"aggregate min on columns" +type Artist_min_fields { + ArtistId: Int + Name: String +} + +"response of any mutation on the table \"Artist\"" +type Artist_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Artist!]! +} + +"input type for inserting object relation for remote table \"Artist\"" +input Artist_obj_rel_insert_input { + data: Artist_insert_input! + "upsert condition" on_conflict: Artist_on_conflict +} + +"on_conflict condition type for table \"Artist\"" +input Artist_on_conflict { + constraint: Artist_constraint! + update_columns: [Artist_update_column!]! = [] + where: Artist_bool_exp +} + +"Ordering options when selecting data from \"Artist\"." +input Artist_order_by { + Albums_aggregate: Album_aggregate_order_by + ArtistId: order_by + Name: order_by +} + +"primary key columns input for table: Artist" +input Artist_pk_columns_input { + ArtistId: Int! +} + +"select columns of table \"Artist\"" +enum Artist_select_column { + "column name" ArtistId + "column name" Name +} + +"input type for updating data in table \"Artist\"" +input Artist_set_input { + Name: String +} + +"aggregate stddev on columns" +type Artist_stddev_fields { + ArtistId: Float +} + +"aggregate stddev_pop on columns" +type Artist_stddev_pop_fields { + ArtistId: Float +} + +"aggregate stddev_samp on columns" +type Artist_stddev_samp_fields { + ArtistId: Float +} + +"Streaming cursor of the table \"Artist\"" +input Artist_stream_cursor_input { + "Stream column input with initial value" initial_value: Artist_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Artist_stream_cursor_value_input { + ArtistId: Int + Name: String +} + +"aggregate sum on columns" +type Artist_sum_fields { + ArtistId: Int +} + +"update columns of table \"Artist\"" +enum Artist_update_column { + "column name" Name +} + +input Artist_updates { + "sets the columns of the filtered rows to the given values" _set: Artist_set_input + "filter the rows which have to be updated" where: Artist_bool_exp! +} + +"aggregate var_pop on columns" +type Artist_var_pop_fields { + ArtistId: Float +} + +"aggregate var_samp on columns" +type Artist_var_samp_fields { + ArtistId: Float +} + +"aggregate variance on columns" +type Artist_variance_fields { + ArtistId: Float +} + +scalar Boolean + +"columns and relationships of \"Customer\"" +type Customer { + Address: String + City: String + Company: String + Country: String + CustomerId: Int! + Email: String! + "An object relationship" + Employee: Employee + Fax: String + FirstName: String! + "An array relationship" + Invoices("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "An aggregate relationship" + Invoices_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + LastName: String! + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregated selection of \"Customer\"" +type Customer_aggregate { + aggregate: Customer_aggregate_fields + nodes: [Customer!]! +} + +input Customer_aggregate_bool_exp { + count: Customer_aggregate_bool_exp_count +} + +input Customer_aggregate_bool_exp_count { + arguments: [Customer_select_column!] + distinct: Boolean + filter: Customer_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Customer\"" +type Customer_aggregate_fields { + avg: Customer_avg_fields + count(columns: [Customer_select_column!], distinct: Boolean): Int! + max: Customer_max_fields + min: Customer_min_fields + stddev: Customer_stddev_fields + stddev_pop: Customer_stddev_pop_fields + stddev_samp: Customer_stddev_samp_fields + sum: Customer_sum_fields + var_pop: Customer_var_pop_fields + var_samp: Customer_var_samp_fields + variance: Customer_variance_fields +} + +"order by aggregate values of table \"Customer\"" +input Customer_aggregate_order_by { + avg: Customer_avg_order_by + count: order_by + max: Customer_max_order_by + min: Customer_min_order_by + stddev: Customer_stddev_order_by + stddev_pop: Customer_stddev_pop_order_by + stddev_samp: Customer_stddev_samp_order_by + sum: Customer_sum_order_by + var_pop: Customer_var_pop_order_by + var_samp: Customer_var_samp_order_by + variance: Customer_variance_order_by +} + +"input type for inserting array relation for remote table \"Customer\"" +input Customer_arr_rel_insert_input { + data: [Customer_insert_input!]! + "upsert condition" on_conflict: Customer_on_conflict +} + +"aggregate avg on columns" +type Customer_avg_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by avg() on columns of table \"Customer\"" +input Customer_avg_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"Boolean expression to filter rows from the table \"Customer\". All fields are combined with a logical 'AND'." +input Customer_bool_exp { + Address: String_comparison_exp + City: String_comparison_exp + Company: String_comparison_exp + Country: String_comparison_exp + CustomerId: Int_comparison_exp + Email: String_comparison_exp + Employee: Employee_bool_exp + Fax: String_comparison_exp + FirstName: String_comparison_exp + Invoices: Invoice_bool_exp + Invoices_aggregate: Invoice_aggregate_bool_exp + LastName: String_comparison_exp + Phone: String_comparison_exp + PostalCode: String_comparison_exp + State: String_comparison_exp + SupportRepId: Int_comparison_exp + _and: [Customer_bool_exp!] + _not: Customer_bool_exp + _or: [Customer_bool_exp!] +} + +"unique or primary key constraints on table \"Customer\"" +enum Customer_constraint { + "unique or primary key constraint on columns \"CustomerId\"" PK_Customer +} + +"input type for incrementing numeric columns in table \"Customer\"" +input Customer_inc_input { + SupportRepId: Int +} + +"input type for inserting data into table \"Customer\"" +input Customer_insert_input { + Address: String + City: String + Company: String + Country: String + Email: String + Employee: Employee_obj_rel_insert_input + Fax: String + FirstName: String + Invoices: Invoice_arr_rel_insert_input + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate max on columns" +type Customer_max_fields { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"order by max() on columns of table \"Customer\"" +input Customer_max_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Fax: order_by + FirstName: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"aggregate min on columns" +type Customer_min_fields { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"order by min() on columns of table \"Customer\"" +input Customer_min_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Fax: order_by + FirstName: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"response of any mutation on the table \"Customer\"" +type Customer_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Customer!]! +} + +"input type for inserting object relation for remote table \"Customer\"" +input Customer_obj_rel_insert_input { + data: Customer_insert_input! + "upsert condition" on_conflict: Customer_on_conflict +} + +"on_conflict condition type for table \"Customer\"" +input Customer_on_conflict { + constraint: Customer_constraint! + update_columns: [Customer_update_column!]! = [] + where: Customer_bool_exp +} + +"Ordering options when selecting data from \"Customer\"." +input Customer_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Employee: Employee_order_by + Fax: order_by + FirstName: order_by + Invoices_aggregate: Invoice_aggregate_order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"primary key columns input for table: Customer" +input Customer_pk_columns_input { + CustomerId: Int! +} + +"select columns of table \"Customer\"" +enum Customer_select_column { + "column name" Address + "column name" City + "column name" Company + "column name" Country + "column name" CustomerId + "column name" Email + "column name" Fax + "column name" FirstName + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" State + "column name" SupportRepId +} + +"input type for updating data in table \"Customer\"" +input Customer_set_input { + Address: String + City: String + Company: String + Country: String + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate stddev on columns" +type Customer_stddev_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev() on columns of table \"Customer\"" +input Customer_stddev_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate stddev_pop on columns" +type Customer_stddev_pop_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev_pop() on columns of table \"Customer\"" +input Customer_stddev_pop_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate stddev_samp on columns" +type Customer_stddev_samp_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev_samp() on columns of table \"Customer\"" +input Customer_stddev_samp_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"Streaming cursor of the table \"Customer\"" +input Customer_stream_cursor_input { + "Stream column input with initial value" initial_value: Customer_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Customer_stream_cursor_value_input { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate sum on columns" +type Customer_sum_fields { + CustomerId: Int + SupportRepId: Int +} + +"order by sum() on columns of table \"Customer\"" +input Customer_sum_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"update columns of table \"Customer\"" +enum Customer_update_column { + "column name" Address + "column name" City + "column name" Company + "column name" Country + "column name" Email + "column name" Fax + "column name" FirstName + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" State + "column name" SupportRepId +} + +input Customer_updates { + "increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input + "sets the columns of the filtered rows to the given values" _set: Customer_set_input + "filter the rows which have to be updated" where: Customer_bool_exp! +} + +"aggregate var_pop on columns" +type Customer_var_pop_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by var_pop() on columns of table \"Customer\"" +input Customer_var_pop_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate var_samp on columns" +type Customer_var_samp_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by var_samp() on columns of table \"Customer\"" +input Customer_var_samp_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate variance on columns" +type Customer_variance_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by variance() on columns of table \"Customer\"" +input Customer_variance_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"columns and relationships of \"Employee\"" +type Employee { + Address: String + BirthDate: timestamp + City: String + Country: String + "An array relationship" + Customers("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "An aggregate relationship" + Customers_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + Email: String + "An object relationship" + Employee: Employee + EmployeeId: Int! + "An array relationship" + Employees("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "An aggregate relationship" + Employees_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + Fax: String + FirstName: String! + HireDate: timestamp + LastName: String! + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregated selection of \"Employee\"" +type Employee_aggregate { + aggregate: Employee_aggregate_fields + nodes: [Employee!]! +} + +input Employee_aggregate_bool_exp { + count: Employee_aggregate_bool_exp_count +} + +input Employee_aggregate_bool_exp_count { + arguments: [Employee_select_column!] + distinct: Boolean + filter: Employee_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Employee\"" +type Employee_aggregate_fields { + avg: Employee_avg_fields + count(columns: [Employee_select_column!], distinct: Boolean): Int! + max: Employee_max_fields + min: Employee_min_fields + stddev: Employee_stddev_fields + stddev_pop: Employee_stddev_pop_fields + stddev_samp: Employee_stddev_samp_fields + sum: Employee_sum_fields + var_pop: Employee_var_pop_fields + var_samp: Employee_var_samp_fields + variance: Employee_variance_fields +} + +"order by aggregate values of table \"Employee\"" +input Employee_aggregate_order_by { + avg: Employee_avg_order_by + count: order_by + max: Employee_max_order_by + min: Employee_min_order_by + stddev: Employee_stddev_order_by + stddev_pop: Employee_stddev_pop_order_by + stddev_samp: Employee_stddev_samp_order_by + sum: Employee_sum_order_by + var_pop: Employee_var_pop_order_by + var_samp: Employee_var_samp_order_by + variance: Employee_variance_order_by +} + +"input type for inserting array relation for remote table \"Employee\"" +input Employee_arr_rel_insert_input { + data: [Employee_insert_input!]! + "upsert condition" on_conflict: Employee_on_conflict +} + +"aggregate avg on columns" +type Employee_avg_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by avg() on columns of table \"Employee\"" +input Employee_avg_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"Boolean expression to filter rows from the table \"Employee\". All fields are combined with a logical 'AND'." +input Employee_bool_exp { + Address: String_comparison_exp + BirthDate: timestamp_comparison_exp + City: String_comparison_exp + Country: String_comparison_exp + Customers: Customer_bool_exp + Customers_aggregate: Customer_aggregate_bool_exp + Email: String_comparison_exp + Employee: Employee_bool_exp + EmployeeId: Int_comparison_exp + Employees: Employee_bool_exp + Employees_aggregate: Employee_aggregate_bool_exp + Fax: String_comparison_exp + FirstName: String_comparison_exp + HireDate: timestamp_comparison_exp + LastName: String_comparison_exp + Phone: String_comparison_exp + PostalCode: String_comparison_exp + ReportsTo: Int_comparison_exp + State: String_comparison_exp + Title: String_comparison_exp + _and: [Employee_bool_exp!] + _not: Employee_bool_exp + _or: [Employee_bool_exp!] +} + +"unique or primary key constraints on table \"Employee\"" +enum Employee_constraint { + "unique or primary key constraint on columns \"EmployeeId\"" PK_Employee +} + +"input type for incrementing numeric columns in table \"Employee\"" +input Employee_inc_input { + ReportsTo: Int +} + +"input type for inserting data into table \"Employee\"" +input Employee_insert_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Customers: Customer_arr_rel_insert_input + Email: String + Employee: Employee_obj_rel_insert_input + Employees: Employee_arr_rel_insert_input + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate max on columns" +type Employee_max_fields { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"order by max() on columns of table \"Employee\"" +input Employee_max_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Email: order_by + EmployeeId: order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"aggregate min on columns" +type Employee_min_fields { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"order by min() on columns of table \"Employee\"" +input Employee_min_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Email: order_by + EmployeeId: order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"response of any mutation on the table \"Employee\"" +type Employee_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Employee!]! +} + +"input type for inserting object relation for remote table \"Employee\"" +input Employee_obj_rel_insert_input { + data: Employee_insert_input! + "upsert condition" on_conflict: Employee_on_conflict +} + +"on_conflict condition type for table \"Employee\"" +input Employee_on_conflict { + constraint: Employee_constraint! + update_columns: [Employee_update_column!]! = [] + where: Employee_bool_exp +} + +"Ordering options when selecting data from \"Employee\"." +input Employee_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Customers_aggregate: Customer_aggregate_order_by + Email: order_by + Employee: Employee_order_by + EmployeeId: order_by + Employees_aggregate: Employee_aggregate_order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"primary key columns input for table: Employee" +input Employee_pk_columns_input { + EmployeeId: Int! +} + +"select columns of table \"Employee\"" +enum Employee_select_column { + "column name" Address + "column name" BirthDate + "column name" City + "column name" Country + "column name" Email + "column name" EmployeeId + "column name" Fax + "column name" FirstName + "column name" HireDate + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" ReportsTo + "column name" State + "column name" Title +} + +"input type for updating data in table \"Employee\"" +input Employee_set_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate stddev on columns" +type Employee_stddev_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev() on columns of table \"Employee\"" +input Employee_stddev_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate stddev_pop on columns" +type Employee_stddev_pop_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev_pop() on columns of table \"Employee\"" +input Employee_stddev_pop_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate stddev_samp on columns" +type Employee_stddev_samp_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev_samp() on columns of table \"Employee\"" +input Employee_stddev_samp_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"Streaming cursor of the table \"Employee\"" +input Employee_stream_cursor_input { + "Stream column input with initial value" initial_value: Employee_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Employee_stream_cursor_value_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate sum on columns" +type Employee_sum_fields { + EmployeeId: Int + ReportsTo: Int +} + +"order by sum() on columns of table \"Employee\"" +input Employee_sum_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"update columns of table \"Employee\"" +enum Employee_update_column { + "column name" Address + "column name" BirthDate + "column name" City + "column name" Country + "column name" Email + "column name" Fax + "column name" FirstName + "column name" HireDate + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" ReportsTo + "column name" State + "column name" Title +} + +input Employee_updates { + "increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input + "sets the columns of the filtered rows to the given values" _set: Employee_set_input + "filter the rows which have to be updated" where: Employee_bool_exp! +} + +"aggregate var_pop on columns" +type Employee_var_pop_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by var_pop() on columns of table \"Employee\"" +input Employee_var_pop_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate var_samp on columns" +type Employee_var_samp_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by var_samp() on columns of table \"Employee\"" +input Employee_var_samp_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate variance on columns" +type Employee_variance_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by variance() on columns of table \"Employee\"" +input Employee_variance_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +scalar Float + +"columns and relationships of \"Genre\"" +type Genre { + GenreId: Int! + Name: String + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"Genre\"" +type Genre_aggregate { + aggregate: Genre_aggregate_fields + nodes: [Genre!]! +} + +"aggregate fields of \"Genre\"" +type Genre_aggregate_fields { + avg: Genre_avg_fields + count(columns: [Genre_select_column!], distinct: Boolean): Int! + max: Genre_max_fields + min: Genre_min_fields + stddev: Genre_stddev_fields + stddev_pop: Genre_stddev_pop_fields + stddev_samp: Genre_stddev_samp_fields + sum: Genre_sum_fields + var_pop: Genre_var_pop_fields + var_samp: Genre_var_samp_fields + variance: Genre_variance_fields +} + +"aggregate avg on columns" +type Genre_avg_fields { + GenreId: Float +} + +"Boolean expression to filter rows from the table \"Genre\". All fields are combined with a logical 'AND'." +input Genre_bool_exp { + GenreId: Int_comparison_exp + Name: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [Genre_bool_exp!] + _not: Genre_bool_exp + _or: [Genre_bool_exp!] +} + +"unique or primary key constraints on table \"Genre\"" +enum Genre_constraint { + "unique or primary key constraint on columns \"GenreId\"" PK_Genre +} + +"input type for inserting data into table \"Genre\"" +input Genre_insert_input { + Name: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type Genre_max_fields { + GenreId: Int + Name: String +} + +"aggregate min on columns" +type Genre_min_fields { + GenreId: Int + Name: String +} + +"response of any mutation on the table \"Genre\"" +type Genre_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Genre!]! +} + +"input type for inserting object relation for remote table \"Genre\"" +input Genre_obj_rel_insert_input { + data: Genre_insert_input! + "upsert condition" on_conflict: Genre_on_conflict +} + +"on_conflict condition type for table \"Genre\"" +input Genre_on_conflict { + constraint: Genre_constraint! + update_columns: [Genre_update_column!]! = [] + where: Genre_bool_exp +} + +"Ordering options when selecting data from \"Genre\"." +input Genre_order_by { + GenreId: order_by + Name: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: Genre" +input Genre_pk_columns_input { + GenreId: Int! +} + +"select columns of table \"Genre\"" +enum Genre_select_column { + "column name" GenreId + "column name" Name +} + +"input type for updating data in table \"Genre\"" +input Genre_set_input { + Name: String +} + +"aggregate stddev on columns" +type Genre_stddev_fields { + GenreId: Float +} + +"aggregate stddev_pop on columns" +type Genre_stddev_pop_fields { + GenreId: Float +} + +"aggregate stddev_samp on columns" +type Genre_stddev_samp_fields { + GenreId: Float +} + +"Streaming cursor of the table \"Genre\"" +input Genre_stream_cursor_input { + "Stream column input with initial value" initial_value: Genre_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Genre_stream_cursor_value_input { + GenreId: Int + Name: String +} + +"aggregate sum on columns" +type Genre_sum_fields { + GenreId: Int +} + +"update columns of table \"Genre\"" +enum Genre_update_column { + "column name" Name +} + +input Genre_updates { + "sets the columns of the filtered rows to the given values" _set: Genre_set_input + "filter the rows which have to be updated" where: Genre_bool_exp! +} + +"aggregate var_pop on columns" +type Genre_var_pop_fields { + GenreId: Float +} + +"aggregate var_samp on columns" +type Genre_var_samp_fields { + GenreId: Float +} + +"aggregate variance on columns" +type Genre_variance_fields { + GenreId: Float +} + +scalar Int + +"Boolean expression to compare columns of type \"Int\". All fields are combined with logical 'AND'." +input Int_comparison_exp { + _eq: Int + _gt: Int + _gte: Int + _in: [Int!] + _is_null: Boolean + _lt: Int + _lte: Int + _neq: Int + _nin: [Int!] +} + +"columns and relationships of \"Invoice\"" +type Invoice { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + "An object relationship" + Customer: Customer! + CustomerId: Int! + InvoiceDate: timestamp! + InvoiceId: Int! + "An array relationship" + InvoiceLines("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "An aggregate relationship" + InvoiceLines_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + Total: numeric! +} + +"columns and relationships of \"InvoiceLine\"" +type InvoiceLine { + "An object relationship" + Invoice: Invoice! + InvoiceId: Int! + InvoiceLineId: Int! + Quantity: Int! + "An object relationship" + Track: Track! + TrackId: Int! + UnitPrice: numeric! +} + +"aggregated selection of \"InvoiceLine\"" +type InvoiceLine_aggregate { + aggregate: InvoiceLine_aggregate_fields + nodes: [InvoiceLine!]! +} + +input InvoiceLine_aggregate_bool_exp { + count: InvoiceLine_aggregate_bool_exp_count +} + +input InvoiceLine_aggregate_bool_exp_count { + arguments: [InvoiceLine_select_column!] + distinct: Boolean + filter: InvoiceLine_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"InvoiceLine\"" +type InvoiceLine_aggregate_fields { + avg: InvoiceLine_avg_fields + count(columns: [InvoiceLine_select_column!], distinct: Boolean): Int! + max: InvoiceLine_max_fields + min: InvoiceLine_min_fields + stddev: InvoiceLine_stddev_fields + stddev_pop: InvoiceLine_stddev_pop_fields + stddev_samp: InvoiceLine_stddev_samp_fields + sum: InvoiceLine_sum_fields + var_pop: InvoiceLine_var_pop_fields + var_samp: InvoiceLine_var_samp_fields + variance: InvoiceLine_variance_fields +} + +"order by aggregate values of table \"InvoiceLine\"" +input InvoiceLine_aggregate_order_by { + avg: InvoiceLine_avg_order_by + count: order_by + max: InvoiceLine_max_order_by + min: InvoiceLine_min_order_by + stddev: InvoiceLine_stddev_order_by + stddev_pop: InvoiceLine_stddev_pop_order_by + stddev_samp: InvoiceLine_stddev_samp_order_by + sum: InvoiceLine_sum_order_by + var_pop: InvoiceLine_var_pop_order_by + var_samp: InvoiceLine_var_samp_order_by + variance: InvoiceLine_variance_order_by +} + +"input type for inserting array relation for remote table \"InvoiceLine\"" +input InvoiceLine_arr_rel_insert_input { + data: [InvoiceLine_insert_input!]! + "upsert condition" on_conflict: InvoiceLine_on_conflict +} + +"aggregate avg on columns" +type InvoiceLine_avg_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by avg() on columns of table \"InvoiceLine\"" +input InvoiceLine_avg_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Boolean expression to filter rows from the table \"InvoiceLine\". All fields are combined with a logical 'AND'." +input InvoiceLine_bool_exp { + Invoice: Invoice_bool_exp + InvoiceId: Int_comparison_exp + InvoiceLineId: Int_comparison_exp + Quantity: Int_comparison_exp + Track: Track_bool_exp + TrackId: Int_comparison_exp + UnitPrice: numeric_comparison_exp + _and: [InvoiceLine_bool_exp!] + _not: InvoiceLine_bool_exp + _or: [InvoiceLine_bool_exp!] +} + +"unique or primary key constraints on table \"InvoiceLine\"" +enum InvoiceLine_constraint { + "unique or primary key constraint on columns \"InvoiceLineId\"" PK_InvoiceLine +} + +"input type for incrementing numeric columns in table \"InvoiceLine\"" +input InvoiceLine_inc_input { + InvoiceId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"input type for inserting data into table \"InvoiceLine\"" +input InvoiceLine_insert_input { + Invoice: Invoice_obj_rel_insert_input + InvoiceId: Int + Quantity: Int + Track: Track_obj_rel_insert_input + TrackId: Int + UnitPrice: numeric +} + +"aggregate max on columns" +type InvoiceLine_max_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by max() on columns of table \"InvoiceLine\"" +input InvoiceLine_max_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate min on columns" +type InvoiceLine_min_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by min() on columns of table \"InvoiceLine\"" +input InvoiceLine_min_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"response of any mutation on the table \"InvoiceLine\"" +type InvoiceLine_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [InvoiceLine!]! +} + +"on_conflict condition type for table \"InvoiceLine\"" +input InvoiceLine_on_conflict { + constraint: InvoiceLine_constraint! + update_columns: [InvoiceLine_update_column!]! = [] + where: InvoiceLine_bool_exp +} + +"Ordering options when selecting data from \"InvoiceLine\"." +input InvoiceLine_order_by { + Invoice: Invoice_order_by + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + Track: Track_order_by + TrackId: order_by + UnitPrice: order_by +} + +"primary key columns input for table: InvoiceLine" +input InvoiceLine_pk_columns_input { + InvoiceLineId: Int! +} + +"select columns of table \"InvoiceLine\"" +enum InvoiceLine_select_column { + "column name" InvoiceId + "column name" InvoiceLineId + "column name" Quantity + "column name" TrackId + "column name" UnitPrice +} + +"input type for updating data in table \"InvoiceLine\"" +input InvoiceLine_set_input { + InvoiceId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"aggregate stddev on columns" +type InvoiceLine_stddev_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_pop on columns" +type InvoiceLine_stddev_pop_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_pop() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_pop_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_samp on columns" +type InvoiceLine_stddev_samp_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_samp() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_samp_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Streaming cursor of the table \"InvoiceLine\"" +input InvoiceLine_stream_cursor_input { + "Stream column input with initial value" initial_value: InvoiceLine_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input InvoiceLine_stream_cursor_value_input { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"aggregate sum on columns" +type InvoiceLine_sum_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by sum() on columns of table \"InvoiceLine\"" +input InvoiceLine_sum_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"update columns of table \"InvoiceLine\"" +enum InvoiceLine_update_column { + "column name" InvoiceId + "column name" Quantity + "column name" TrackId + "column name" UnitPrice +} + +input InvoiceLine_updates { + "increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input + "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input + "filter the rows which have to be updated" where: InvoiceLine_bool_exp! +} + +"aggregate var_pop on columns" +type InvoiceLine_var_pop_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_pop() on columns of table \"InvoiceLine\"" +input InvoiceLine_var_pop_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate var_samp on columns" +type InvoiceLine_var_samp_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_samp() on columns of table \"InvoiceLine\"" +input InvoiceLine_var_samp_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate variance on columns" +type InvoiceLine_variance_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by variance() on columns of table \"InvoiceLine\"" +input InvoiceLine_variance_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregated selection of \"Invoice\"" +type Invoice_aggregate { + aggregate: Invoice_aggregate_fields + nodes: [Invoice!]! +} + +input Invoice_aggregate_bool_exp { + count: Invoice_aggregate_bool_exp_count +} + +input Invoice_aggregate_bool_exp_count { + arguments: [Invoice_select_column!] + distinct: Boolean + filter: Invoice_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Invoice\"" +type Invoice_aggregate_fields { + avg: Invoice_avg_fields + count(columns: [Invoice_select_column!], distinct: Boolean): Int! + max: Invoice_max_fields + min: Invoice_min_fields + stddev: Invoice_stddev_fields + stddev_pop: Invoice_stddev_pop_fields + stddev_samp: Invoice_stddev_samp_fields + sum: Invoice_sum_fields + var_pop: Invoice_var_pop_fields + var_samp: Invoice_var_samp_fields + variance: Invoice_variance_fields +} + +"order by aggregate values of table \"Invoice\"" +input Invoice_aggregate_order_by { + avg: Invoice_avg_order_by + count: order_by + max: Invoice_max_order_by + min: Invoice_min_order_by + stddev: Invoice_stddev_order_by + stddev_pop: Invoice_stddev_pop_order_by + stddev_samp: Invoice_stddev_samp_order_by + sum: Invoice_sum_order_by + var_pop: Invoice_var_pop_order_by + var_samp: Invoice_var_samp_order_by + variance: Invoice_variance_order_by +} + +"input type for inserting array relation for remote table \"Invoice\"" +input Invoice_arr_rel_insert_input { + data: [Invoice_insert_input!]! + "upsert condition" on_conflict: Invoice_on_conflict +} + +"aggregate avg on columns" +type Invoice_avg_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by avg() on columns of table \"Invoice\"" +input Invoice_avg_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"Boolean expression to filter rows from the table \"Invoice\". All fields are combined with a logical 'AND'." +input Invoice_bool_exp { + BillingAddress: String_comparison_exp + BillingCity: String_comparison_exp + BillingCountry: String_comparison_exp + BillingPostalCode: String_comparison_exp + BillingState: String_comparison_exp + Customer: Customer_bool_exp + CustomerId: Int_comparison_exp + InvoiceDate: timestamp_comparison_exp + InvoiceId: Int_comparison_exp + InvoiceLines: InvoiceLine_bool_exp + InvoiceLines_aggregate: InvoiceLine_aggregate_bool_exp + Total: numeric_comparison_exp + _and: [Invoice_bool_exp!] + _not: Invoice_bool_exp + _or: [Invoice_bool_exp!] +} + +"unique or primary key constraints on table \"Invoice\"" +enum Invoice_constraint { + "unique or primary key constraint on columns \"InvoiceId\"" PK_Invoice +} + +"input type for incrementing numeric columns in table \"Invoice\"" +input Invoice_inc_input { + CustomerId: Int + Total: numeric +} + +"input type for inserting data into table \"Invoice\"" +input Invoice_insert_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + Customer: Customer_obj_rel_insert_input + CustomerId: Int + InvoiceDate: timestamp + InvoiceLines: InvoiceLine_arr_rel_insert_input + Total: numeric +} + +"aggregate max on columns" +type Invoice_max_fields { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"order by max() on columns of table \"Invoice\"" +input Invoice_max_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate min on columns" +type Invoice_min_fields { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"order by min() on columns of table \"Invoice\"" +input Invoice_min_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + Total: order_by +} + +"response of any mutation on the table \"Invoice\"" +type Invoice_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Invoice!]! +} + +"input type for inserting object relation for remote table \"Invoice\"" +input Invoice_obj_rel_insert_input { + data: Invoice_insert_input! + "upsert condition" on_conflict: Invoice_on_conflict +} + +"on_conflict condition type for table \"Invoice\"" +input Invoice_on_conflict { + constraint: Invoice_constraint! + update_columns: [Invoice_update_column!]! = [] + where: Invoice_bool_exp +} + +"Ordering options when selecting data from \"Invoice\"." +input Invoice_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + Customer: Customer_order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + InvoiceLines_aggregate: InvoiceLine_aggregate_order_by + Total: order_by +} + +"primary key columns input for table: Invoice" +input Invoice_pk_columns_input { + InvoiceId: Int! +} + +"select columns of table \"Invoice\"" +enum Invoice_select_column { + "column name" BillingAddress + "column name" BillingCity + "column name" BillingCountry + "column name" BillingPostalCode + "column name" BillingState + "column name" CustomerId + "column name" InvoiceDate + "column name" InvoiceId + "column name" Total +} + +"input type for updating data in table \"Invoice\"" +input Invoice_set_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + Total: numeric +} + +"aggregate stddev on columns" +type Invoice_stddev_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev() on columns of table \"Invoice\"" +input Invoice_stddev_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate stddev_pop on columns" +type Invoice_stddev_pop_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev_pop() on columns of table \"Invoice\"" +input Invoice_stddev_pop_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate stddev_samp on columns" +type Invoice_stddev_samp_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev_samp() on columns of table \"Invoice\"" +input Invoice_stddev_samp_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"Streaming cursor of the table \"Invoice\"" +input Invoice_stream_cursor_input { + "Stream column input with initial value" initial_value: Invoice_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Invoice_stream_cursor_value_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"aggregate sum on columns" +type Invoice_sum_fields { + CustomerId: Int + InvoiceId: Int + Total: numeric +} + +"order by sum() on columns of table \"Invoice\"" +input Invoice_sum_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"update columns of table \"Invoice\"" +enum Invoice_update_column { + "column name" BillingAddress + "column name" BillingCity + "column name" BillingCountry + "column name" BillingPostalCode + "column name" BillingState + "column name" CustomerId + "column name" InvoiceDate + "column name" Total +} + +input Invoice_updates { + "increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input + "sets the columns of the filtered rows to the given values" _set: Invoice_set_input + "filter the rows which have to be updated" where: Invoice_bool_exp! +} + +"aggregate var_pop on columns" +type Invoice_var_pop_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by var_pop() on columns of table \"Invoice\"" +input Invoice_var_pop_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate var_samp on columns" +type Invoice_var_samp_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by var_samp() on columns of table \"Invoice\"" +input Invoice_var_samp_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate variance on columns" +type Invoice_variance_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by variance() on columns of table \"Invoice\"" +input Invoice_variance_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"columns and relationships of \"MediaType\"" +type MediaType { + MediaTypeId: Int! + Name: String + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"MediaType\"" +type MediaType_aggregate { + aggregate: MediaType_aggregate_fields + nodes: [MediaType!]! +} + +"aggregate fields of \"MediaType\"" +type MediaType_aggregate_fields { + avg: MediaType_avg_fields + count(columns: [MediaType_select_column!], distinct: Boolean): Int! + max: MediaType_max_fields + min: MediaType_min_fields + stddev: MediaType_stddev_fields + stddev_pop: MediaType_stddev_pop_fields + stddev_samp: MediaType_stddev_samp_fields + sum: MediaType_sum_fields + var_pop: MediaType_var_pop_fields + var_samp: MediaType_var_samp_fields + variance: MediaType_variance_fields +} + +"aggregate avg on columns" +type MediaType_avg_fields { + MediaTypeId: Float +} + +"Boolean expression to filter rows from the table \"MediaType\". All fields are combined with a logical 'AND'." +input MediaType_bool_exp { + MediaTypeId: Int_comparison_exp + Name: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [MediaType_bool_exp!] + _not: MediaType_bool_exp + _or: [MediaType_bool_exp!] +} + +"unique or primary key constraints on table \"MediaType\"" +enum MediaType_constraint { + "unique or primary key constraint on columns \"MediaTypeId\"" PK_MediaType +} + +"input type for inserting data into table \"MediaType\"" +input MediaType_insert_input { + Name: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type MediaType_max_fields { + MediaTypeId: Int + Name: String +} + +"aggregate min on columns" +type MediaType_min_fields { + MediaTypeId: Int + Name: String +} + +"response of any mutation on the table \"MediaType\"" +type MediaType_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [MediaType!]! +} + +"input type for inserting object relation for remote table \"MediaType\"" +input MediaType_obj_rel_insert_input { + data: MediaType_insert_input! + "upsert condition" on_conflict: MediaType_on_conflict +} + +"on_conflict condition type for table \"MediaType\"" +input MediaType_on_conflict { + constraint: MediaType_constraint! + update_columns: [MediaType_update_column!]! = [] + where: MediaType_bool_exp +} + +"Ordering options when selecting data from \"MediaType\"." +input MediaType_order_by { + MediaTypeId: order_by + Name: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: MediaType" +input MediaType_pk_columns_input { + MediaTypeId: Int! +} + +"select columns of table \"MediaType\"" +enum MediaType_select_column { + "column name" MediaTypeId + "column name" Name +} + +"input type for updating data in table \"MediaType\"" +input MediaType_set_input { + Name: String +} + +"aggregate stddev on columns" +type MediaType_stddev_fields { + MediaTypeId: Float +} + +"aggregate stddev_pop on columns" +type MediaType_stddev_pop_fields { + MediaTypeId: Float +} + +"aggregate stddev_samp on columns" +type MediaType_stddev_samp_fields { + MediaTypeId: Float +} + +"Streaming cursor of the table \"MediaType\"" +input MediaType_stream_cursor_input { + "Stream column input with initial value" initial_value: MediaType_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input MediaType_stream_cursor_value_input { + MediaTypeId: Int + Name: String +} + +"aggregate sum on columns" +type MediaType_sum_fields { + MediaTypeId: Int +} + +"update columns of table \"MediaType\"" +enum MediaType_update_column { + "column name" Name +} + +input MediaType_updates { + "sets the columns of the filtered rows to the given values" _set: MediaType_set_input + "filter the rows which have to be updated" where: MediaType_bool_exp! +} + +"aggregate var_pop on columns" +type MediaType_var_pop_fields { + MediaTypeId: Float +} + +"aggregate var_samp on columns" +type MediaType_var_samp_fields { + MediaTypeId: Float +} + +"aggregate variance on columns" +type MediaType_variance_fields { + MediaTypeId: Float +} + +"columns and relationships of \"Playlist\"" +type Playlist { + Name: String + PlaylistId: Int! + "An array relationship" + PlaylistTracks("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "An aggregate relationship" + PlaylistTracks_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! +} + +"columns and relationships of \"PlaylistTrack\"" +type PlaylistTrack { + "An object relationship" + Playlist: Playlist! + PlaylistId: Int! + "An object relationship" + Track: Track! + TrackId: Int! +} + +"aggregated selection of \"PlaylistTrack\"" +type PlaylistTrack_aggregate { + aggregate: PlaylistTrack_aggregate_fields + nodes: [PlaylistTrack!]! +} + +input PlaylistTrack_aggregate_bool_exp { + count: PlaylistTrack_aggregate_bool_exp_count +} + +input PlaylistTrack_aggregate_bool_exp_count { + arguments: [PlaylistTrack_select_column!] + distinct: Boolean + filter: PlaylistTrack_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"PlaylistTrack\"" +type PlaylistTrack_aggregate_fields { + avg: PlaylistTrack_avg_fields + count(columns: [PlaylistTrack_select_column!], distinct: Boolean): Int! + max: PlaylistTrack_max_fields + min: PlaylistTrack_min_fields + stddev: PlaylistTrack_stddev_fields + stddev_pop: PlaylistTrack_stddev_pop_fields + stddev_samp: PlaylistTrack_stddev_samp_fields + sum: PlaylistTrack_sum_fields + var_pop: PlaylistTrack_var_pop_fields + var_samp: PlaylistTrack_var_samp_fields + variance: PlaylistTrack_variance_fields +} + +"order by aggregate values of table \"PlaylistTrack\"" +input PlaylistTrack_aggregate_order_by { + avg: PlaylistTrack_avg_order_by + count: order_by + max: PlaylistTrack_max_order_by + min: PlaylistTrack_min_order_by + stddev: PlaylistTrack_stddev_order_by + stddev_pop: PlaylistTrack_stddev_pop_order_by + stddev_samp: PlaylistTrack_stddev_samp_order_by + sum: PlaylistTrack_sum_order_by + var_pop: PlaylistTrack_var_pop_order_by + var_samp: PlaylistTrack_var_samp_order_by + variance: PlaylistTrack_variance_order_by +} + +"input type for inserting array relation for remote table \"PlaylistTrack\"" +input PlaylistTrack_arr_rel_insert_input { + data: [PlaylistTrack_insert_input!]! + "upsert condition" on_conflict: PlaylistTrack_on_conflict +} + +"aggregate avg on columns" +type PlaylistTrack_avg_fields { + PlaylistId: Float + TrackId: Float +} + +"order by avg() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_avg_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"Boolean expression to filter rows from the table \"PlaylistTrack\". All fields are combined with a logical 'AND'." +input PlaylistTrack_bool_exp { + Playlist: Playlist_bool_exp + PlaylistId: Int_comparison_exp + Track: Track_bool_exp + TrackId: Int_comparison_exp + _and: [PlaylistTrack_bool_exp!] + _not: PlaylistTrack_bool_exp + _or: [PlaylistTrack_bool_exp!] +} + +"unique or primary key constraints on table \"PlaylistTrack\"" +enum PlaylistTrack_constraint { + "unique or primary key constraint on columns \"TrackId\", \"PlaylistId\"" PK_PlaylistTrack +} + +"input type for incrementing numeric columns in table \"PlaylistTrack\"" +input PlaylistTrack_inc_input { + PlaylistId: Int + TrackId: Int +} + +"input type for inserting data into table \"PlaylistTrack\"" +input PlaylistTrack_insert_input { + Playlist: Playlist_obj_rel_insert_input + PlaylistId: Int + Track: Track_obj_rel_insert_input + TrackId: Int +} + +"aggregate max on columns" +type PlaylistTrack_max_fields { + PlaylistId: Int + TrackId: Int +} + +"order by max() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_max_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate min on columns" +type PlaylistTrack_min_fields { + PlaylistId: Int + TrackId: Int +} + +"order by min() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_min_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"response of any mutation on the table \"PlaylistTrack\"" +type PlaylistTrack_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [PlaylistTrack!]! +} + +"on_conflict condition type for table \"PlaylistTrack\"" +input PlaylistTrack_on_conflict { + constraint: PlaylistTrack_constraint! + update_columns: [PlaylistTrack_update_column!]! = [] + where: PlaylistTrack_bool_exp +} + +"Ordering options when selecting data from \"PlaylistTrack\"." +input PlaylistTrack_order_by { + Playlist: Playlist_order_by + PlaylistId: order_by + Track: Track_order_by + TrackId: order_by +} + +"primary key columns input for table: PlaylistTrack" +input PlaylistTrack_pk_columns_input { + PlaylistId: Int! + TrackId: Int! +} + +"select columns of table \"PlaylistTrack\"" +enum PlaylistTrack_select_column { + "column name" PlaylistId + "column name" TrackId +} + +"input type for updating data in table \"PlaylistTrack\"" +input PlaylistTrack_set_input { + PlaylistId: Int + TrackId: Int +} + +"aggregate stddev on columns" +type PlaylistTrack_stddev_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate stddev_pop on columns" +type PlaylistTrack_stddev_pop_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev_pop() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_pop_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate stddev_samp on columns" +type PlaylistTrack_stddev_samp_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev_samp() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_samp_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"Streaming cursor of the table \"PlaylistTrack\"" +input PlaylistTrack_stream_cursor_input { + "Stream column input with initial value" initial_value: PlaylistTrack_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input PlaylistTrack_stream_cursor_value_input { + PlaylistId: Int + TrackId: Int +} + +"aggregate sum on columns" +type PlaylistTrack_sum_fields { + PlaylistId: Int + TrackId: Int +} + +"order by sum() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_sum_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"update columns of table \"PlaylistTrack\"" +enum PlaylistTrack_update_column { + "column name" PlaylistId + "column name" TrackId +} + +input PlaylistTrack_updates { + "increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input + "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input + "filter the rows which have to be updated" where: PlaylistTrack_bool_exp! +} + +"aggregate var_pop on columns" +type PlaylistTrack_var_pop_fields { + PlaylistId: Float + TrackId: Float +} + +"order by var_pop() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_var_pop_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate var_samp on columns" +type PlaylistTrack_var_samp_fields { + PlaylistId: Float + TrackId: Float +} + +"order by var_samp() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_var_samp_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate variance on columns" +type PlaylistTrack_variance_fields { + PlaylistId: Float + TrackId: Float +} + +"order by variance() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_variance_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregated selection of \"Playlist\"" +type Playlist_aggregate { + aggregate: Playlist_aggregate_fields + nodes: [Playlist!]! +} + +"aggregate fields of \"Playlist\"" +type Playlist_aggregate_fields { + avg: Playlist_avg_fields + count(columns: [Playlist_select_column!], distinct: Boolean): Int! + max: Playlist_max_fields + min: Playlist_min_fields + stddev: Playlist_stddev_fields + stddev_pop: Playlist_stddev_pop_fields + stddev_samp: Playlist_stddev_samp_fields + sum: Playlist_sum_fields + var_pop: Playlist_var_pop_fields + var_samp: Playlist_var_samp_fields + variance: Playlist_variance_fields +} + +"aggregate avg on columns" +type Playlist_avg_fields { + PlaylistId: Float +} + +"Boolean expression to filter rows from the table \"Playlist\". All fields are combined with a logical 'AND'." +input Playlist_bool_exp { + Name: String_comparison_exp + PlaylistId: Int_comparison_exp + PlaylistTracks: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: PlaylistTrack_aggregate_bool_exp + _and: [Playlist_bool_exp!] + _not: Playlist_bool_exp + _or: [Playlist_bool_exp!] +} + +"unique or primary key constraints on table \"Playlist\"" +enum Playlist_constraint { + "unique or primary key constraint on columns \"PlaylistId\"" PK_Playlist +} + +"input type for inserting data into table \"Playlist\"" +input Playlist_insert_input { + Name: String + PlaylistTracks: PlaylistTrack_arr_rel_insert_input +} + +"aggregate max on columns" +type Playlist_max_fields { + Name: String + PlaylistId: Int +} + +"aggregate min on columns" +type Playlist_min_fields { + Name: String + PlaylistId: Int +} + +"response of any mutation on the table \"Playlist\"" +type Playlist_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Playlist!]! +} + +"input type for inserting object relation for remote table \"Playlist\"" +input Playlist_obj_rel_insert_input { + data: Playlist_insert_input! + "upsert condition" on_conflict: Playlist_on_conflict +} + +"on_conflict condition type for table \"Playlist\"" +input Playlist_on_conflict { + constraint: Playlist_constraint! + update_columns: [Playlist_update_column!]! = [] + where: Playlist_bool_exp +} + +"Ordering options when selecting data from \"Playlist\"." +input Playlist_order_by { + Name: order_by + PlaylistId: order_by + PlaylistTracks_aggregate: PlaylistTrack_aggregate_order_by +} + +"primary key columns input for table: Playlist" +input Playlist_pk_columns_input { + PlaylistId: Int! +} + +"select columns of table \"Playlist\"" +enum Playlist_select_column { + "column name" Name + "column name" PlaylistId +} + +"input type for updating data in table \"Playlist\"" +input Playlist_set_input { + Name: String +} + +"aggregate stddev on columns" +type Playlist_stddev_fields { + PlaylistId: Float +} + +"aggregate stddev_pop on columns" +type Playlist_stddev_pop_fields { + PlaylistId: Float +} + +"aggregate stddev_samp on columns" +type Playlist_stddev_samp_fields { + PlaylistId: Float +} + +"Streaming cursor of the table \"Playlist\"" +input Playlist_stream_cursor_input { + "Stream column input with initial value" initial_value: Playlist_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Playlist_stream_cursor_value_input { + Name: String + PlaylistId: Int +} + +"aggregate sum on columns" +type Playlist_sum_fields { + PlaylistId: Int +} + +"update columns of table \"Playlist\"" +enum Playlist_update_column { + "column name" Name +} + +input Playlist_updates { + "sets the columns of the filtered rows to the given values" _set: Playlist_set_input + "filter the rows which have to be updated" where: Playlist_bool_exp! +} + +"aggregate var_pop on columns" +type Playlist_var_pop_fields { + PlaylistId: Float +} + +"aggregate var_samp on columns" +type Playlist_var_samp_fields { + PlaylistId: Float +} + +"aggregate variance on columns" +type Playlist_variance_fields { + PlaylistId: Float +} + +scalar String + +"Boolean expression to compare columns of type \"String\". All fields are combined with logical 'AND'." +input String_comparison_exp { + _eq: String + _gt: String + _gte: String + "does the column match the given case-insensitive pattern" _ilike: String + _in: [String!] + "does the column match the given POSIX regular expression, case insensitive" _iregex: String + _is_null: Boolean + "does the column match the given pattern" _like: String + _lt: String + _lte: String + _neq: String + "does the column NOT match the given case-insensitive pattern" _nilike: String + _nin: [String!] + "does the column NOT match the given POSIX regular expression, case insensitive" _niregex: String + "does the column NOT match the given pattern" _nlike: String + "does the column NOT match the given POSIX regular expression, case sensitive" _nregex: String + "does the column NOT match the given SQL regular expression" _nsimilar: String + "does the column match the given POSIX regular expression, case sensitive" _regex: String + "does the column match the given SQL regular expression" _similar: String +} + +"columns and relationships of \"Track\"" +type Track { + "An object relationship" + Album: Album + AlbumId: Int + Bytes: Int + Composer: String + "An object relationship" + Genre: Genre + GenreId: Int + "An array relationship" + InvoiceLines("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "An aggregate relationship" + InvoiceLines_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "An object relationship" + MediaType: MediaType! + MediaTypeId: Int! + Milliseconds: Int! + Name: String! + "An array relationship" + PlaylistTracks("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "An aggregate relationship" + PlaylistTracks_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + TrackId: Int! + UnitPrice: numeric! +} + +"aggregated selection of \"Track\"" +type Track_aggregate { + aggregate: Track_aggregate_fields + nodes: [Track!]! +} + +input Track_aggregate_bool_exp { + count: Track_aggregate_bool_exp_count +} + +input Track_aggregate_bool_exp_count { + arguments: [Track_select_column!] + distinct: Boolean + filter: Track_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Track\"" +type Track_aggregate_fields { + avg: Track_avg_fields + count(columns: [Track_select_column!], distinct: Boolean): Int! + max: Track_max_fields + min: Track_min_fields + stddev: Track_stddev_fields + stddev_pop: Track_stddev_pop_fields + stddev_samp: Track_stddev_samp_fields + sum: Track_sum_fields + var_pop: Track_var_pop_fields + var_samp: Track_var_samp_fields + variance: Track_variance_fields +} + +"order by aggregate values of table \"Track\"" +input Track_aggregate_order_by { + avg: Track_avg_order_by + count: order_by + max: Track_max_order_by + min: Track_min_order_by + stddev: Track_stddev_order_by + stddev_pop: Track_stddev_pop_order_by + stddev_samp: Track_stddev_samp_order_by + sum: Track_sum_order_by + var_pop: Track_var_pop_order_by + var_samp: Track_var_samp_order_by + variance: Track_variance_order_by +} + +"input type for inserting array relation for remote table \"Track\"" +input Track_arr_rel_insert_input { + data: [Track_insert_input!]! + "upsert condition" on_conflict: Track_on_conflict +} + +"aggregate avg on columns" +type Track_avg_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by avg() on columns of table \"Track\"" +input Track_avg_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Boolean expression to filter rows from the table \"Track\". All fields are combined with a logical 'AND'." +input Track_bool_exp { + Album: Album_bool_exp + AlbumId: Int_comparison_exp + Bytes: Int_comparison_exp + Composer: String_comparison_exp + Genre: Genre_bool_exp + GenreId: Int_comparison_exp + InvoiceLines: InvoiceLine_bool_exp + InvoiceLines_aggregate: InvoiceLine_aggregate_bool_exp + MediaType: MediaType_bool_exp + MediaTypeId: Int_comparison_exp + Milliseconds: Int_comparison_exp + Name: String_comparison_exp + PlaylistTracks: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: PlaylistTrack_aggregate_bool_exp + TrackId: Int_comparison_exp + UnitPrice: numeric_comparison_exp + _and: [Track_bool_exp!] + _not: Track_bool_exp + _or: [Track_bool_exp!] +} + +"unique or primary key constraints on table \"Track\"" +enum Track_constraint { + "unique or primary key constraint on columns \"TrackId\"" PK_Track +} + +"input type for incrementing numeric columns in table \"Track\"" +input Track_inc_input { + AlbumId: Int + Bytes: Int + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + UnitPrice: numeric +} + +"input type for inserting data into table \"Track\"" +input Track_insert_input { + Album: Album_obj_rel_insert_input + AlbumId: Int + Bytes: Int + Composer: String + Genre: Genre_obj_rel_insert_input + GenreId: Int + InvoiceLines: InvoiceLine_arr_rel_insert_input + MediaType: MediaType_obj_rel_insert_input + MediaTypeId: Int + Milliseconds: Int + Name: String + PlaylistTracks: PlaylistTrack_arr_rel_insert_input + UnitPrice: numeric +} + +"aggregate max on columns" +type Track_max_fields { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"order by max() on columns of table \"Track\"" +input Track_max_order_by { + AlbumId: order_by + Bytes: order_by + Composer: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate min on columns" +type Track_min_fields { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"order by min() on columns of table \"Track\"" +input Track_min_order_by { + AlbumId: order_by + Bytes: order_by + Composer: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + TrackId: order_by + UnitPrice: order_by +} + +"response of any mutation on the table \"Track\"" +type Track_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Track!]! +} + +"input type for inserting object relation for remote table \"Track\"" +input Track_obj_rel_insert_input { + data: Track_insert_input! + "upsert condition" on_conflict: Track_on_conflict +} + +"on_conflict condition type for table \"Track\"" +input Track_on_conflict { + constraint: Track_constraint! + update_columns: [Track_update_column!]! = [] + where: Track_bool_exp +} + +"Ordering options when selecting data from \"Track\"." +input Track_order_by { + Album: Album_order_by + AlbumId: order_by + Bytes: order_by + Composer: order_by + Genre: Genre_order_by + GenreId: order_by + InvoiceLines_aggregate: InvoiceLine_aggregate_order_by + MediaType: MediaType_order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + PlaylistTracks_aggregate: PlaylistTrack_aggregate_order_by + TrackId: order_by + UnitPrice: order_by +} + +"primary key columns input for table: Track" +input Track_pk_columns_input { + TrackId: Int! +} + +"select columns of table \"Track\"" +enum Track_select_column { + "column name" AlbumId + "column name" Bytes + "column name" Composer + "column name" GenreId + "column name" MediaTypeId + "column name" Milliseconds + "column name" Name + "column name" TrackId + "column name" UnitPrice +} + +"input type for updating data in table \"Track\"" +input Track_set_input { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + UnitPrice: numeric +} + +"aggregate stddev on columns" +type Track_stddev_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev() on columns of table \"Track\"" +input Track_stddev_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_pop on columns" +type Track_stddev_pop_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_pop() on columns of table \"Track\"" +input Track_stddev_pop_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_samp on columns" +type Track_stddev_samp_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_samp() on columns of table \"Track\"" +input Track_stddev_samp_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Streaming cursor of the table \"Track\"" +input Track_stream_cursor_input { + "Stream column input with initial value" initial_value: Track_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Track_stream_cursor_value_input { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"aggregate sum on columns" +type Track_sum_fields { + AlbumId: Int + Bytes: Int + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + TrackId: Int + UnitPrice: numeric +} + +"order by sum() on columns of table \"Track\"" +input Track_sum_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"update columns of table \"Track\"" +enum Track_update_column { + "column name" AlbumId + "column name" Bytes + "column name" Composer + "column name" GenreId + "column name" MediaTypeId + "column name" Milliseconds + "column name" Name + "column name" UnitPrice +} + +input Track_updates { + "increments the numeric columns with given value of the filtered values" _inc: Track_inc_input + "sets the columns of the filtered rows to the given values" _set: Track_set_input + "filter the rows which have to be updated" where: Track_bool_exp! +} + +"aggregate var_pop on columns" +type Track_var_pop_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_pop() on columns of table \"Track\"" +input Track_var_pop_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate var_samp on columns" +type Track_var_samp_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_samp() on columns of table \"Track\"" +input Track_var_samp_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate variance on columns" +type Track_variance_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by variance() on columns of table \"Track\"" +input Track_variance_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"ordering argument of a cursor" +enum cursor_ordering { + "ascending ordering of the cursor" ASC + "descending ordering of the cursor" DESC +} + +"mutation root" +type mutation_root { + "delete data from the table: \"Album\"" + delete_Album("filter the rows which have to be deleted" where: Album_bool_exp!): Album_mutation_response + "delete single row from the table: \"Album\"" + delete_Album_by_pk(AlbumId: Int!): Album + "delete data from the table: \"Artist\"" + delete_Artist("filter the rows which have to be deleted" where: Artist_bool_exp!): Artist_mutation_response + "delete single row from the table: \"Artist\"" + delete_Artist_by_pk(ArtistId: Int!): Artist + "delete data from the table: \"Customer\"" + delete_Customer("filter the rows which have to be deleted" where: Customer_bool_exp!): Customer_mutation_response + "delete single row from the table: \"Customer\"" + delete_Customer_by_pk(CustomerId: Int!): Customer + "delete data from the table: \"Employee\"" + delete_Employee("filter the rows which have to be deleted" where: Employee_bool_exp!): Employee_mutation_response + "delete single row from the table: \"Employee\"" + delete_Employee_by_pk(EmployeeId: Int!): Employee + "delete data from the table: \"Genre\"" + delete_Genre("filter the rows which have to be deleted" where: Genre_bool_exp!): Genre_mutation_response + "delete single row from the table: \"Genre\"" + delete_Genre_by_pk(GenreId: Int!): Genre + "delete data from the table: \"Invoice\"" + delete_Invoice("filter the rows which have to be deleted" where: Invoice_bool_exp!): Invoice_mutation_response + "delete data from the table: \"InvoiceLine\"" + delete_InvoiceLine("filter the rows which have to be deleted" where: InvoiceLine_bool_exp!): InvoiceLine_mutation_response + "delete single row from the table: \"InvoiceLine\"" + delete_InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "delete single row from the table: \"Invoice\"" + delete_Invoice_by_pk(InvoiceId: Int!): Invoice + "delete data from the table: \"MediaType\"" + delete_MediaType("filter the rows which have to be deleted" where: MediaType_bool_exp!): MediaType_mutation_response + "delete single row from the table: \"MediaType\"" + delete_MediaType_by_pk(MediaTypeId: Int!): MediaType + "delete data from the table: \"Playlist\"" + delete_Playlist("filter the rows which have to be deleted" where: Playlist_bool_exp!): Playlist_mutation_response + "delete data from the table: \"PlaylistTrack\"" + delete_PlaylistTrack("filter the rows which have to be deleted" where: PlaylistTrack_bool_exp!): PlaylistTrack_mutation_response + "delete single row from the table: \"PlaylistTrack\"" + delete_PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "delete single row from the table: \"Playlist\"" + delete_Playlist_by_pk(PlaylistId: Int!): Playlist + "delete data from the table: \"Track\"" + delete_Track("filter the rows which have to be deleted" where: Track_bool_exp!): Track_mutation_response + "delete single row from the table: \"Track\"" + delete_Track_by_pk(TrackId: Int!): Track + "insert data into the table: \"Album\"" + insert_Album("the rows to be inserted" objects: [Album_insert_input!]!, "upsert condition" on_conflict: Album_on_conflict): Album_mutation_response + "insert a single row into the table: \"Album\"" + insert_Album_one("the row to be inserted" object: Album_insert_input!, "upsert condition" on_conflict: Album_on_conflict): Album + "insert data into the table: \"Artist\"" + insert_Artist("the rows to be inserted" objects: [Artist_insert_input!]!, "upsert condition" on_conflict: Artist_on_conflict): Artist_mutation_response + "insert a single row into the table: \"Artist\"" + insert_Artist_one("the row to be inserted" object: Artist_insert_input!, "upsert condition" on_conflict: Artist_on_conflict): Artist + "insert data into the table: \"Customer\"" + insert_Customer("the rows to be inserted" objects: [Customer_insert_input!]!, "upsert condition" on_conflict: Customer_on_conflict): Customer_mutation_response + "insert a single row into the table: \"Customer\"" + insert_Customer_one("the row to be inserted" object: Customer_insert_input!, "upsert condition" on_conflict: Customer_on_conflict): Customer + "insert data into the table: \"Employee\"" + insert_Employee("the rows to be inserted" objects: [Employee_insert_input!]!, "upsert condition" on_conflict: Employee_on_conflict): Employee_mutation_response + "insert a single row into the table: \"Employee\"" + insert_Employee_one("the row to be inserted" object: Employee_insert_input!, "upsert condition" on_conflict: Employee_on_conflict): Employee + "insert data into the table: \"Genre\"" + insert_Genre("the rows to be inserted" objects: [Genre_insert_input!]!, "upsert condition" on_conflict: Genre_on_conflict): Genre_mutation_response + "insert a single row into the table: \"Genre\"" + insert_Genre_one("the row to be inserted" object: Genre_insert_input!, "upsert condition" on_conflict: Genre_on_conflict): Genre + "insert data into the table: \"Invoice\"" + insert_Invoice("the rows to be inserted" objects: [Invoice_insert_input!]!, "upsert condition" on_conflict: Invoice_on_conflict): Invoice_mutation_response + "insert data into the table: \"InvoiceLine\"" + insert_InvoiceLine("the rows to be inserted" objects: [InvoiceLine_insert_input!]!, "upsert condition" on_conflict: InvoiceLine_on_conflict): InvoiceLine_mutation_response + "insert a single row into the table: \"InvoiceLine\"" + insert_InvoiceLine_one("the row to be inserted" object: InvoiceLine_insert_input!, "upsert condition" on_conflict: InvoiceLine_on_conflict): InvoiceLine + "insert a single row into the table: \"Invoice\"" + insert_Invoice_one("the row to be inserted" object: Invoice_insert_input!, "upsert condition" on_conflict: Invoice_on_conflict): Invoice + "insert data into the table: \"MediaType\"" + insert_MediaType("the rows to be inserted" objects: [MediaType_insert_input!]!, "upsert condition" on_conflict: MediaType_on_conflict): MediaType_mutation_response + "insert a single row into the table: \"MediaType\"" + insert_MediaType_one("the row to be inserted" object: MediaType_insert_input!, "upsert condition" on_conflict: MediaType_on_conflict): MediaType + "insert data into the table: \"Playlist\"" + insert_Playlist("the rows to be inserted" objects: [Playlist_insert_input!]!, "upsert condition" on_conflict: Playlist_on_conflict): Playlist_mutation_response + "insert data into the table: \"PlaylistTrack\"" + insert_PlaylistTrack("the rows to be inserted" objects: [PlaylistTrack_insert_input!]!, "upsert condition" on_conflict: PlaylistTrack_on_conflict): PlaylistTrack_mutation_response + "insert a single row into the table: \"PlaylistTrack\"" + insert_PlaylistTrack_one("the row to be inserted" object: PlaylistTrack_insert_input!, "upsert condition" on_conflict: PlaylistTrack_on_conflict): PlaylistTrack + "insert a single row into the table: \"Playlist\"" + insert_Playlist_one("the row to be inserted" object: Playlist_insert_input!, "upsert condition" on_conflict: Playlist_on_conflict): Playlist + "insert data into the table: \"Track\"" + insert_Track("the rows to be inserted" objects: [Track_insert_input!]!, "upsert condition" on_conflict: Track_on_conflict): Track_mutation_response + "insert a single row into the table: \"Track\"" + insert_Track_one("the row to be inserted" object: Track_insert_input!, "upsert condition" on_conflict: Track_on_conflict): Track + "update data of the table: \"Album\"" + update_Album("increments the numeric columns with given value of the filtered values" _inc: Album_inc_input, "sets the columns of the filtered rows to the given values" _set: Album_set_input, "filter the rows which have to be updated" where: Album_bool_exp!): Album_mutation_response + "update single row of the table: \"Album\"" + update_Album_by_pk("increments the numeric columns with given value of the filtered values" _inc: Album_inc_input, "sets the columns of the filtered rows to the given values" _set: Album_set_input, pk_columns: Album_pk_columns_input!): Album + "update multiples rows of table: \"Album\"" + update_Album_many("updates to execute, in order" updates: [Album_updates!]!): [Album_mutation_response] + "update data of the table: \"Artist\"" + update_Artist("sets the columns of the filtered rows to the given values" _set: Artist_set_input, "filter the rows which have to be updated" where: Artist_bool_exp!): Artist_mutation_response + "update single row of the table: \"Artist\"" + update_Artist_by_pk("sets the columns of the filtered rows to the given values" _set: Artist_set_input, pk_columns: Artist_pk_columns_input!): Artist + "update multiples rows of table: \"Artist\"" + update_Artist_many("updates to execute, in order" updates: [Artist_updates!]!): [Artist_mutation_response] + "update data of the table: \"Customer\"" + update_Customer("increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input, "sets the columns of the filtered rows to the given values" _set: Customer_set_input, "filter the rows which have to be updated" where: Customer_bool_exp!): Customer_mutation_response + "update single row of the table: \"Customer\"" + update_Customer_by_pk("increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input, "sets the columns of the filtered rows to the given values" _set: Customer_set_input, pk_columns: Customer_pk_columns_input!): Customer + "update multiples rows of table: \"Customer\"" + update_Customer_many("updates to execute, in order" updates: [Customer_updates!]!): [Customer_mutation_response] + "update data of the table: \"Employee\"" + update_Employee("increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input, "sets the columns of the filtered rows to the given values" _set: Employee_set_input, "filter the rows which have to be updated" where: Employee_bool_exp!): Employee_mutation_response + "update single row of the table: \"Employee\"" + update_Employee_by_pk("increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input, "sets the columns of the filtered rows to the given values" _set: Employee_set_input, pk_columns: Employee_pk_columns_input!): Employee + "update multiples rows of table: \"Employee\"" + update_Employee_many("updates to execute, in order" updates: [Employee_updates!]!): [Employee_mutation_response] + "update data of the table: \"Genre\"" + update_Genre("sets the columns of the filtered rows to the given values" _set: Genre_set_input, "filter the rows which have to be updated" where: Genre_bool_exp!): Genre_mutation_response + "update single row of the table: \"Genre\"" + update_Genre_by_pk("sets the columns of the filtered rows to the given values" _set: Genre_set_input, pk_columns: Genre_pk_columns_input!): Genre + "update multiples rows of table: \"Genre\"" + update_Genre_many("updates to execute, in order" updates: [Genre_updates!]!): [Genre_mutation_response] + "update data of the table: \"Invoice\"" + update_Invoice("increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input, "sets the columns of the filtered rows to the given values" _set: Invoice_set_input, "filter the rows which have to be updated" where: Invoice_bool_exp!): Invoice_mutation_response + "update data of the table: \"InvoiceLine\"" + update_InvoiceLine("increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input, "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input, "filter the rows which have to be updated" where: InvoiceLine_bool_exp!): InvoiceLine_mutation_response + "update single row of the table: \"InvoiceLine\"" + update_InvoiceLine_by_pk("increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input, "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input, pk_columns: InvoiceLine_pk_columns_input!): InvoiceLine + "update multiples rows of table: \"InvoiceLine\"" + update_InvoiceLine_many("updates to execute, in order" updates: [InvoiceLine_updates!]!): [InvoiceLine_mutation_response] + "update single row of the table: \"Invoice\"" + update_Invoice_by_pk("increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input, "sets the columns of the filtered rows to the given values" _set: Invoice_set_input, pk_columns: Invoice_pk_columns_input!): Invoice + "update multiples rows of table: \"Invoice\"" + update_Invoice_many("updates to execute, in order" updates: [Invoice_updates!]!): [Invoice_mutation_response] + "update data of the table: \"MediaType\"" + update_MediaType("sets the columns of the filtered rows to the given values" _set: MediaType_set_input, "filter the rows which have to be updated" where: MediaType_bool_exp!): MediaType_mutation_response + "update single row of the table: \"MediaType\"" + update_MediaType_by_pk("sets the columns of the filtered rows to the given values" _set: MediaType_set_input, pk_columns: MediaType_pk_columns_input!): MediaType + "update multiples rows of table: \"MediaType\"" + update_MediaType_many("updates to execute, in order" updates: [MediaType_updates!]!): [MediaType_mutation_response] + "update data of the table: \"Playlist\"" + update_Playlist("sets the columns of the filtered rows to the given values" _set: Playlist_set_input, "filter the rows which have to be updated" where: Playlist_bool_exp!): Playlist_mutation_response + "update data of the table: \"PlaylistTrack\"" + update_PlaylistTrack("increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input, "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input, "filter the rows which have to be updated" where: PlaylistTrack_bool_exp!): PlaylistTrack_mutation_response + "update single row of the table: \"PlaylistTrack\"" + update_PlaylistTrack_by_pk("increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input, "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input, pk_columns: PlaylistTrack_pk_columns_input!): PlaylistTrack + "update multiples rows of table: \"PlaylistTrack\"" + update_PlaylistTrack_many("updates to execute, in order" updates: [PlaylistTrack_updates!]!): [PlaylistTrack_mutation_response] + "update single row of the table: \"Playlist\"" + update_Playlist_by_pk("sets the columns of the filtered rows to the given values" _set: Playlist_set_input, pk_columns: Playlist_pk_columns_input!): Playlist + "update multiples rows of table: \"Playlist\"" + update_Playlist_many("updates to execute, in order" updates: [Playlist_updates!]!): [Playlist_mutation_response] + "update data of the table: \"Track\"" + update_Track("increments the numeric columns with given value of the filtered values" _inc: Track_inc_input, "sets the columns of the filtered rows to the given values" _set: Track_set_input, "filter the rows which have to be updated" where: Track_bool_exp!): Track_mutation_response + "update single row of the table: \"Track\"" + update_Track_by_pk("increments the numeric columns with given value of the filtered values" _inc: Track_inc_input, "sets the columns of the filtered rows to the given values" _set: Track_set_input, pk_columns: Track_pk_columns_input!): Track + "update multiples rows of table: \"Track\"" + update_Track_many("updates to execute, in order" updates: [Track_updates!]!): [Track_mutation_response] +} + +scalar numeric + +"Boolean expression to compare columns of type \"numeric\". All fields are combined with logical 'AND'." +input numeric_comparison_exp { + _eq: numeric + _gt: numeric + _gte: numeric + _in: [numeric!] + _is_null: Boolean + _lt: numeric + _lte: numeric + _neq: numeric + _nin: [numeric!] +} + +"column ordering options" +enum order_by { + "in ascending order, nulls last" asc + "in ascending order, nulls first" asc_nulls_first + "in ascending order, nulls last" asc_nulls_last + "in descending order, nulls first" desc + "in descending order, nulls first" desc_nulls_first + "in descending order, nulls last" desc_nulls_last +} + +type query_root { + "fetch data from the table: \"Album\"" + Album("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch aggregated fields from the table: \"Album\"" + Album_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + "fetch data from the table: \"Album\" using primary key columns" + Album_by_pk(AlbumId: Int!): Album + "fetch data from the table: \"Artist\"" + Artist("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch aggregated fields from the table: \"Artist\"" + Artist_aggregate("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): Artist_aggregate! + "fetch data from the table: \"Artist\" using primary key columns" + Artist_by_pk(ArtistId: Int!): Artist + "fetch data from the table: \"Customer\"" + Customer("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch aggregated fields from the table: \"Customer\"" + Customer_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + "fetch data from the table: \"Customer\" using primary key columns" + Customer_by_pk(CustomerId: Int!): Customer + "fetch data from the table: \"Employee\"" + Employee("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch aggregated fields from the table: \"Employee\"" + Employee_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + "fetch data from the table: \"Employee\" using primary key columns" + Employee_by_pk(EmployeeId: Int!): Employee + "fetch data from the table: \"Genre\"" + Genre("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch aggregated fields from the table: \"Genre\"" + Genre_aggregate("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): Genre_aggregate! + "fetch data from the table: \"Genre\" using primary key columns" + Genre_by_pk(GenreId: Int!): Genre + "fetch data from the table: \"Invoice\"" + Invoice("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"InvoiceLine\"" + InvoiceLine("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"InvoiceLine\"" + InvoiceLine_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "fetch data from the table: \"InvoiceLine\" using primary key columns" + InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "fetch aggregated fields from the table: \"Invoice\"" + Invoice_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + "fetch data from the table: \"Invoice\" using primary key columns" + Invoice_by_pk(InvoiceId: Int!): Invoice + "fetch data from the table: \"MediaType\"" + MediaType("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch aggregated fields from the table: \"MediaType\"" + MediaType_aggregate("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): MediaType_aggregate! + "fetch data from the table: \"MediaType\" using primary key columns" + MediaType_by_pk(MediaTypeId: Int!): MediaType + "fetch data from the table: \"Playlist\"" + Playlist("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"PlaylistTrack\"" + PlaylistTrack("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"PlaylistTrack\"" + PlaylistTrack_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + "fetch data from the table: \"PlaylistTrack\" using primary key columns" + PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "fetch aggregated fields from the table: \"Playlist\"" + Playlist_aggregate("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): Playlist_aggregate! + "fetch data from the table: \"Playlist\" using primary key columns" + Playlist_by_pk(PlaylistId: Int!): Playlist + "fetch data from the table: \"Track\"" + Track("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "fetch aggregated fields from the table: \"Track\"" + Track_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! + "fetch data from the table: \"Track\" using primary key columns" + Track_by_pk(TrackId: Int!): Track +} + +type subscription_root { + "fetch data from the table: \"Album\"" + Album("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch aggregated fields from the table: \"Album\"" + Album_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + "fetch data from the table: \"Album\" using primary key columns" + Album_by_pk(AlbumId: Int!): Album + "fetch data from the table in a streaming manner: \"Album\"" + Album_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Album_stream_cursor_input]!, "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch data from the table: \"Artist\"" + Artist("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch aggregated fields from the table: \"Artist\"" + Artist_aggregate("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): Artist_aggregate! + "fetch data from the table: \"Artist\" using primary key columns" + Artist_by_pk(ArtistId: Int!): Artist + "fetch data from the table in a streaming manner: \"Artist\"" + Artist_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Artist_stream_cursor_input]!, "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch data from the table: \"Customer\"" + Customer("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch aggregated fields from the table: \"Customer\"" + Customer_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + "fetch data from the table: \"Customer\" using primary key columns" + Customer_by_pk(CustomerId: Int!): Customer + "fetch data from the table in a streaming manner: \"Customer\"" + Customer_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Customer_stream_cursor_input]!, "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch data from the table: \"Employee\"" + Employee("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch aggregated fields from the table: \"Employee\"" + Employee_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + "fetch data from the table: \"Employee\" using primary key columns" + Employee_by_pk(EmployeeId: Int!): Employee + "fetch data from the table in a streaming manner: \"Employee\"" + Employee_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Employee_stream_cursor_input]!, "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch data from the table: \"Genre\"" + Genre("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch aggregated fields from the table: \"Genre\"" + Genre_aggregate("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): Genre_aggregate! + "fetch data from the table: \"Genre\" using primary key columns" + Genre_by_pk(GenreId: Int!): Genre + "fetch data from the table in a streaming manner: \"Genre\"" + Genre_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Genre_stream_cursor_input]!, "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch data from the table: \"Invoice\"" + Invoice("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"InvoiceLine\"" + InvoiceLine("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"InvoiceLine\"" + InvoiceLine_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "fetch data from the table: \"InvoiceLine\" using primary key columns" + InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "fetch data from the table in a streaming manner: \"InvoiceLine\"" + InvoiceLine_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [InvoiceLine_stream_cursor_input]!, "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"Invoice\"" + Invoice_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + "fetch data from the table: \"Invoice\" using primary key columns" + Invoice_by_pk(InvoiceId: Int!): Invoice + "fetch data from the table in a streaming manner: \"Invoice\"" + Invoice_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Invoice_stream_cursor_input]!, "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"MediaType\"" + MediaType("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch aggregated fields from the table: \"MediaType\"" + MediaType_aggregate("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): MediaType_aggregate! + "fetch data from the table: \"MediaType\" using primary key columns" + MediaType_by_pk(MediaTypeId: Int!): MediaType + "fetch data from the table in a streaming manner: \"MediaType\"" + MediaType_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [MediaType_stream_cursor_input]!, "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch data from the table: \"Playlist\"" + Playlist("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"PlaylistTrack\"" + PlaylistTrack("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"PlaylistTrack\"" + PlaylistTrack_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + "fetch data from the table: \"PlaylistTrack\" using primary key columns" + PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "fetch data from the table in a streaming manner: \"PlaylistTrack\"" + PlaylistTrack_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [PlaylistTrack_stream_cursor_input]!, "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"Playlist\"" + Playlist_aggregate("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): Playlist_aggregate! + "fetch data from the table: \"Playlist\" using primary key columns" + Playlist_by_pk(PlaylistId: Int!): Playlist + "fetch data from the table in a streaming manner: \"Playlist\"" + Playlist_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Playlist_stream_cursor_input]!, "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"Track\"" + Track("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "fetch aggregated fields from the table: \"Track\"" + Track_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! + "fetch data from the table: \"Track\" using primary key columns" + Track_by_pk(TrackId: Int!): Track + "fetch data from the table in a streaming manner: \"Track\"" + Track_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Track_stream_cursor_input]!, "filter the rows returned" where: Track_bool_exp): [Track!]! +} + +scalar timestamp + +"Boolean expression to compare columns of type \"timestamp\". All fields are combined with logical 'AND'." +input timestamp_comparison_exp { + _eq: timestamp + _gt: timestamp + _gte: timestamp + _in: [timestamp!] + _is_null: Boolean + _lt: timestamp + _lte: timestamp + _neq: timestamp + _nin: [timestamp!] +} diff --git a/crates/ndc-graphql/tests/config-1/mutations/01_single_operation.request.json b/crates/ndc-graphql/tests/config-1/mutations/01_single_operation.request.json new file mode 100644 index 0000000..fcb17ce --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/mutations/01_single_operation.request.json @@ -0,0 +1,33 @@ +{ + "$schema": "_mutation_request.schema.json", + "operations": [ + { + "type": "procedure", + "name": "update_Album_by_pk", + "arguments": { + "_set": { + "ArtistId": 1 + }, + "pk_columns": { + "AlbumId": 1 + } + }, + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + } + } + } + } + ], + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-1/mutations/02_multiple_operations.request.json b/crates/ndc-graphql/tests/config-1/mutations/02_multiple_operations.request.json new file mode 100644 index 0000000..efc1603 --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/mutations/02_multiple_operations.request.json @@ -0,0 +1,59 @@ +{ + "operations": [ + { + "type": "procedure", + "name": "update_Album_by_pk", + "arguments": { + "_set": { + "ArtistId": 1 + }, + "pk_columns": { + "AlbumId": 1 + } + }, + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + } + } + } + }, + { + "type": "procedure", + "name": "update_Album_by_pk", + "arguments": { + "_set": { + "ArtistId": 1 + }, + "pk_columns": { + "AlbumId": 1 + } + }, + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + } + } + } + } + ], + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-1/mutations/_mutation_request.schema.json b/crates/ndc-graphql/tests/config-1/mutations/_mutation_request.schema.json new file mode 100644 index 0000000..4ccdb61 --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/mutations/_mutation_request.schema.json @@ -0,0 +1,989 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Mutation Request", + "type": "object", + "required": [ + "collection_relationships", + "operations" + ], + "properties": { + "operations": { + "description": "The mutation operations to perform", + "type": "array", + "items": { + "$ref": "#/definitions/MutationOperation" + } + }, + "collection_relationships": { + "description": "The relationships between collections involved in the entire mutation request", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Relationship" + } + } + }, + "definitions": { + "MutationOperation": { + "title": "Mutation Operation", + "oneOf": [ + { + "type": "object", + "required": [ + "arguments", + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "procedure" + ] + }, + "name": { + "description": "The name of a procedure", + "type": "string" + }, + "arguments": { + "description": "Any named procedure arguments", + "type": "object", + "additionalProperties": true + }, + "fields": { + "description": "The fields to return from the result, or null to return everything", + "anyOf": [ + { + "$ref": "#/definitions/NestedField" + }, + { + "type": "null" + } + ] + } + } + } + ] + }, + "NestedField": { + "title": "NestedField", + "oneOf": [ + { + "title": "NestedObject", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "object" + ] + }, + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Field" + } + } + } + }, + { + "title": "NestedArray", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "array" + ] + }, + "fields": { + "$ref": "#/definitions/NestedField" + } + } + } + ] + }, + "Field": { + "title": "Field", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "type": "string" + }, + "fields": { + "description": "When the type of the column is a (possibly-nullable) array or object, the caller can request a subset of the complete column data, by specifying fields to fetch here. If omitted, the column data will be fetched in full.", + "anyOf": [ + { + "$ref": "#/definitions/NestedField" + }, + { + "type": "null" + } + ] + }, + "arguments": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Argument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "query", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "relationship" + ] + }, + "query": { + "$ref": "#/definitions/Query" + }, + "relationship": { + "description": "The name of the relationship to follow for the subquery", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "Argument": { + "title": "Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + } + ] + }, + "Query": { + "title": "Query", + "type": "object", + "properties": { + "aggregates": { + "description": "Aggregate fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Aggregate" + } + }, + "fields": { + "description": "Fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Field" + } + }, + "limit": { + "description": "Optionally limit to N results", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "offset": { + "description": "Optionally offset from the Nth result", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "order_by": { + "anyOf": [ + { + "$ref": "#/definitions/OrderBy" + }, + { + "type": "null" + } + ] + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "Aggregate": { + "title": "Aggregate", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "distinct", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column_count" + ] + }, + "column": { + "description": "The column to apply the count aggregate function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "distinct": { + "description": "Whether or not only distinct items should be counted", + "type": "boolean" + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count" + ] + } + } + } + ] + }, + "OrderBy": { + "title": "Order By", + "type": "object", + "required": [ + "elements" + ], + "properties": { + "elements": { + "description": "The elements to order by, in priority order", + "type": "array", + "items": { + "$ref": "#/definitions/OrderByElement" + } + } + } + }, + "OrderByElement": { + "title": "Order By Element", + "type": "object", + "required": [ + "order_direction", + "target" + ], + "properties": { + "order_direction": { + "$ref": "#/definitions/OrderDirection" + }, + "target": { + "$ref": "#/definitions/OrderByTarget" + } + } + }, + "OrderDirection": { + "title": "Order Direction", + "type": "string", + "enum": [ + "asc", + "desc" + ] + }, + "OrderByTarget": { + "title": "Order By Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column_aggregate" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count_aggregate" + ] + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + } + ] + }, + "PathElement": { + "title": "Path Element", + "type": "object", + "required": [ + "arguments", + "relationship" + ], + "properties": { + "relationship": { + "description": "The name of the relationship to follow", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + }, + "predicate": { + "description": "A predicate expression to apply to the target collection", + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "RelationshipArgument": { + "title": "Relationship Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "Expression": { + "title": "Expression", + "oneOf": [ + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "and" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "or" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expression", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "not" + ] + }, + "expression": { + "$ref": "#/definitions/Expression" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "$ref": "#/definitions/UnaryComparisonOperator" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "binary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/ComparisonValue" + } + } + }, + { + "type": "object", + "required": [ + "in_collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "exists" + ] + }, + "in_collection": { + "$ref": "#/definitions/ExistsInCollection" + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + } + ] + }, + "ComparisonTarget": { + "title": "Comparison Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "root_collection_column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + ] + }, + "UnaryComparisonOperator": { + "title": "Unary Comparison Operator", + "type": "string", + "enum": [ + "is_null" + ] + }, + "ComparisonValue": { + "title": "Comparison Value", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + } + } + }, + { + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "scalar" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "ExistsInCollection": { + "title": "Exists In Collection", + "oneOf": [ + { + "type": "object", + "required": [ + "arguments", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "related" + ] + }, + "relationship": { + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unrelated" + ] + }, + "collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "Relationship": { + "title": "Relationship", + "type": "object", + "required": [ + "arguments", + "column_mapping", + "relationship_type", + "target_collection" + ], + "properties": { + "column_mapping": { + "description": "A mapping between columns on the source collection to columns on the target collection", + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "relationship_type": { + "$ref": "#/definitions/RelationshipType" + }, + "target_collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + "RelationshipType": { + "title": "Relationship Type", + "type": "string", + "enum": [ + "object", + "array" + ] + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-1/queries/01_basic_query.request.json b/crates/ndc-graphql/tests/config-1/queries/01_basic_query.request.json new file mode 100644 index 0000000..a7f9b1c --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/queries/01_basic_query.request.json @@ -0,0 +1,97 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album", + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + }, + "MediaType": { + "type": "column", + "column": "MediaType", + "fields": { + "type": "object", + "fields": { + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "MediaTypeId": { + "type": "column", + "column": "MediaTypeId", + "fields": null + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "arguments": {}, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-1/queries/02_root_node_parameters.request.json b/crates/ndc-graphql/tests/config-1/queries/02_root_node_parameters.request.json new file mode 100644 index 0000000..47485ce --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/queries/02_root_node_parameters.request.json @@ -0,0 +1,110 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album", + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + }, + "MediaType": { + "type": "column", + "column": "MediaType", + "fields": { + "type": "object", + "fields": { + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "MediaTypeId": { + "type": "column", + "column": "MediaTypeId", + "fields": null + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "arguments": { + "limit": { + "type": "literal", + "value": 20 + }, + "where": { + "type": "literal", + "value": { + "AlbumId": { + "_gt": 5 + } + } + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-1/queries/03_child_node_parameters.request.json b/crates/ndc-graphql/tests/config-1/queries/03_child_node_parameters.request.json new file mode 100644 index 0000000..0c3e211 --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/queries/03_child_node_parameters.request.json @@ -0,0 +1,116 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album", + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + }, + "MediaType": { + "type": "column", + "column": "MediaType", + "fields": { + "type": "object", + "fields": { + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "MediaTypeId": { + "type": "column", + "column": "MediaTypeId", + "fields": null + } + } + } + } + } + } + }, + "arguments": { + "limit": { + "type": "literal", + "value": 5 + } + } + } + } + } + } + } + } + }, + "arguments": { + "limit": { + "type": "literal", + "value": 20 + }, + "where": { + "type": "literal", + "value": { + "AlbumId": { + "_gt": 5 + } + } + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-1/queries/04_foreach.request.json b/crates/ndc-graphql/tests/config-1/queries/04_foreach.request.json new file mode 100644 index 0000000..566254a --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/queries/04_foreach.request.json @@ -0,0 +1,112 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album_by_pk", + "variables": [ + { + "AlbumId": 1, + "TracksWhere": { + "TrackId": { + "_gte": 1 + } + } + }, + { + "AlbumId": 2, + "TracksWhere": { + "TrackId": { + "_gte": 2 + } + } + }, + { + "AlbumId": 3, + "TracksWhere": { + "TrackId": { + "_gte": 3 + } + } + } + ], + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + } + } + } + }, + "arguments": { + "where": { + "type": "variable", + "name": "TracksWhere" + } + } + } + } + } + } + } + }, + "arguments": { + "AlbumId": { + "type": "variable", + "name": "AlbumId" + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-1/queries/_query_request.schema.json b/crates/ndc-graphql/tests/config-1/queries/_query_request.schema.json new file mode 100644 index 0000000..6f13801 --- /dev/null +++ b/crates/ndc-graphql/tests/config-1/queries/_query_request.schema.json @@ -0,0 +1,974 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Query Request", + "description": "This is the request body of the query POST endpoint", + "type": "object", + "required": [ + "arguments", + "collection", + "collection_relationships", + "query" + ], + "properties": { + "collection": { + "description": "The name of a collection", + "type": "string" + }, + "query": { + "description": "The query syntax tree", + "allOf": [ + { + "$ref": "#/definitions/Query" + } + ] + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Argument" + } + }, + "collection_relationships": { + "description": "Any relationships between collections involved in the query request", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Relationship" + } + }, + "variables": { + "description": "One set of named variables for each rowset to fetch. Each variable set should be subtituted in turn, and a fresh set of rows returned.", + "type": [ + "array", + "null" + ], + "items": { + "type": "object", + "additionalProperties": true + } + } + }, + "definitions": { + "Query": { + "title": "Query", + "type": "object", + "properties": { + "aggregates": { + "description": "Aggregate fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Aggregate" + } + }, + "fields": { + "description": "Fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Field" + } + }, + "limit": { + "description": "Optionally limit to N results", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "offset": { + "description": "Optionally offset from the Nth result", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "order_by": { + "anyOf": [ + { + "$ref": "#/definitions/OrderBy" + }, + { + "type": "null" + } + ] + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "Aggregate": { + "title": "Aggregate", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "distinct", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column_count" + ] + }, + "column": { + "description": "The column to apply the count aggregate function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "distinct": { + "description": "Whether or not only distinct items should be counted", + "type": "boolean" + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count" + ] + } + } + } + ] + }, + "Field": { + "title": "Field", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "type": "string" + }, + "fields": { + "description": "When the type of the column is a (possibly-nullable) array or object, the caller can request a subset of the complete column data, by specifying fields to fetch here. If omitted, the column data will be fetched in full.", + "anyOf": [ + { + "$ref": "#/definitions/NestedField" + }, + { + "type": "null" + } + ] + }, + "arguments": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Argument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "query", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "relationship" + ] + }, + "query": { + "$ref": "#/definitions/Query" + }, + "relationship": { + "description": "The name of the relationship to follow for the subquery", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "NestedField": { + "title": "NestedField", + "oneOf": [ + { + "title": "NestedObject", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "object" + ] + }, + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Field" + } + } + } + }, + { + "title": "NestedArray", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "array" + ] + }, + "fields": { + "$ref": "#/definitions/NestedField" + } + } + } + ] + }, + "Argument": { + "title": "Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + } + ] + }, + "RelationshipArgument": { + "title": "Relationship Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "OrderBy": { + "title": "Order By", + "type": "object", + "required": [ + "elements" + ], + "properties": { + "elements": { + "description": "The elements to order by, in priority order", + "type": "array", + "items": { + "$ref": "#/definitions/OrderByElement" + } + } + } + }, + "OrderByElement": { + "title": "Order By Element", + "type": "object", + "required": [ + "order_direction", + "target" + ], + "properties": { + "order_direction": { + "$ref": "#/definitions/OrderDirection" + }, + "target": { + "$ref": "#/definitions/OrderByTarget" + } + } + }, + "OrderDirection": { + "title": "Order Direction", + "type": "string", + "enum": [ + "asc", + "desc" + ] + }, + "OrderByTarget": { + "title": "Order By Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column_aggregate" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count_aggregate" + ] + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + } + ] + }, + "PathElement": { + "title": "Path Element", + "type": "object", + "required": [ + "arguments", + "relationship" + ], + "properties": { + "relationship": { + "description": "The name of the relationship to follow", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + }, + "predicate": { + "description": "A predicate expression to apply to the target collection", + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "Expression": { + "title": "Expression", + "oneOf": [ + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "and" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "or" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expression", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "not" + ] + }, + "expression": { + "$ref": "#/definitions/Expression" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "$ref": "#/definitions/UnaryComparisonOperator" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "binary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/ComparisonValue" + } + } + }, + { + "type": "object", + "required": [ + "in_collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "exists" + ] + }, + "in_collection": { + "$ref": "#/definitions/ExistsInCollection" + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + } + ] + }, + "ComparisonTarget": { + "title": "Comparison Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "root_collection_column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + ] + }, + "UnaryComparisonOperator": { + "title": "Unary Comparison Operator", + "type": "string", + "enum": [ + "is_null" + ] + }, + "ComparisonValue": { + "title": "Comparison Value", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + } + } + }, + { + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "scalar" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "ExistsInCollection": { + "title": "Exists In Collection", + "oneOf": [ + { + "type": "object", + "required": [ + "arguments", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "related" + ] + }, + "relationship": { + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unrelated" + ] + }, + "collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "Relationship": { + "title": "Relationship", + "type": "object", + "required": [ + "arguments", + "column_mapping", + "relationship_type", + "target_collection" + ], + "properties": { + "column_mapping": { + "description": "A mapping between columns on the source collection to columns on the target collection", + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "relationship_type": { + "$ref": "#/definitions/RelationshipType" + }, + "target_collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + "RelationshipType": { + "title": "Relationship Type", + "type": "string", + "enum": [ + "object", + "array" + ] + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/configuration/configuration.json b/crates/ndc-graphql/tests/config-2/configuration/configuration.json new file mode 100644 index 0000000..0433220 --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/configuration/configuration.json @@ -0,0 +1,29 @@ +{ + "$schema": "configuration.schema.json", + "introspection": { + "endpoint": { + "valueFromEnv": "GRAPHQL_ENDPOINT" + }, + "headers": { + "x-hasura-admin-secret": { + "valueFromEnv": "GRAPHQL_ENDPOINT_SECRET" + } + } + }, + "execution": { + "endpoint": { + "valueFromEnv": "GRAPHQL_ENDPOINT" + }, + "headers": {} + }, + "request": { + "forwardHeaders": [ + "Authorization" + ] + }, + "response": { + "forwardHeaders": [ + "Set-Cookie" + ] + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/configuration/configuration.schema.json b/crates/ndc-graphql/tests/config-2/configuration/configuration.schema.json new file mode 100644 index 0000000..88c1025 --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/configuration/configuration.schema.json @@ -0,0 +1,168 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "ServerConfigFile", + "type": "object", + "required": [ + "$schema", + "execution", + "introspection", + "request", + "response" + ], + "properties": { + "$schema": { + "type": "string" + }, + "introspection": { + "description": "Connection Configuration for introspection", + "allOf": [ + { + "$ref": "#/definitions/ConnectionConfigFile" + } + ] + }, + "execution": { + "description": "Connection configuration for query execution", + "allOf": [ + { + "$ref": "#/definitions/ConnectionConfigFile" + } + ] + }, + "request": { + "description": "Optional configuration for requests", + "allOf": [ + { + "$ref": "#/definitions/RequestConfigFile" + } + ] + }, + "response": { + "description": "Optional configuration for responses", + "allOf": [ + { + "$ref": "#/definitions/ResponseConfigFile" + } + ] + } + }, + "definitions": { + "ConnectionConfigFile": { + "type": "object", + "required": [ + "endpoint" + ], + "properties": { + "endpoint": { + "$ref": "#/definitions/ConfigValue" + }, + "headers": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/ConfigValue" + } + } + } + }, + "ConfigValue": { + "oneOf": [ + { + "type": "object", + "required": [ + "value" + ], + "properties": { + "value": { + "type": "string" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "valueFromEnv" + ], + "properties": { + "valueFromEnv": { + "type": "string" + } + }, + "additionalProperties": false + } + ] + }, + "RequestConfigFile": { + "type": "object", + "properties": { + "headersArgument": { + "description": "Name of the headers argument Must not conflict with any arguments of root fields in the target schema Defaults to \"_headers\", set to a different value if there is a conflict", + "type": [ + "string", + "null" + ] + }, + "headersTypeName": { + "description": "Name of the headers argument type Must not conflict with other types in the target schema Defaults to \"_HeaderMap\", set to a different value if there is a conflict", + "type": [ + "string", + "null" + ] + }, + "forwardHeaders": { + "description": "List of headers to from the request Defaults to [], AKA no headers/disabled Supports glob patterns eg. \"X-Hasura-*\" Enabling this requires additional configuration on the ddn side, see docs for more", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + }, + "ResponseConfigFile": { + "type": "object", + "properties": { + "headersField": { + "description": "Name of the headers field in the response type Defaults to \"headers\"", + "type": [ + "string", + "null" + ] + }, + "responseField": { + "description": "Name of the response field in the response type Defaults to \"response\"", + "type": [ + "string", + "null" + ] + }, + "typeNamePrefix": { + "description": "Prefix for response type names Defaults to \"_\" Generated response type names must be unique once prefix and suffix are applied", + "type": [ + "string", + "null" + ] + }, + "typeNameSuffix": { + "description": "Suffix for response type names Defaults to \"Response\" Generated response type names must be unique once prefix and suffix are applied", + "type": [ + "string", + "null" + ] + }, + "forwardHeaders": { + "description": "List of headers to from the response Defaults to [], AKA no headers/disabled Supports glob patterns eg. \"X-Hasura-*\" Enabling this requires additional configuration on the ddn side, see docs for more", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/configuration/schema.graphql b/crates/ndc-graphql/tests/config-2/configuration/schema.graphql new file mode 100644 index 0000000..d301e54 --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/configuration/schema.graphql @@ -0,0 +1,3740 @@ +schema { + query: query_root + mutation: mutation_root +} + +"columns and relationships of \"Album\"" +type Album { + AlbumId: Int! + "An object relationship" + Artist: Artist! + ArtistId: Int! + Title: String! + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"Album\"" +type Album_aggregate { + aggregate: Album_aggregate_fields + nodes: [Album!]! +} + +input Album_aggregate_bool_exp { + count: Album_aggregate_bool_exp_count +} + +input Album_aggregate_bool_exp_count { + arguments: [Album_select_column!] + distinct: Boolean + filter: Album_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Album\"" +type Album_aggregate_fields { + avg: Album_avg_fields + count(columns: [Album_select_column!], distinct: Boolean): Int! + max: Album_max_fields + min: Album_min_fields + stddev: Album_stddev_fields + stddev_pop: Album_stddev_pop_fields + stddev_samp: Album_stddev_samp_fields + sum: Album_sum_fields + var_pop: Album_var_pop_fields + var_samp: Album_var_samp_fields + variance: Album_variance_fields +} + +"order by aggregate values of table \"Album\"" +input Album_aggregate_order_by { + avg: Album_avg_order_by + count: order_by + max: Album_max_order_by + min: Album_min_order_by + stddev: Album_stddev_order_by + stddev_pop: Album_stddev_pop_order_by + stddev_samp: Album_stddev_samp_order_by + sum: Album_sum_order_by + var_pop: Album_var_pop_order_by + var_samp: Album_var_samp_order_by + variance: Album_variance_order_by +} + +"input type for inserting array relation for remote table \"Album\"" +input Album_arr_rel_insert_input { + data: [Album_insert_input!]! + "upsert condition" on_conflict: Album_on_conflict +} + +"aggregate avg on columns" +type Album_avg_fields { + AlbumId: Float + ArtistId: Float +} + +"order by avg() on columns of table \"Album\"" +input Album_avg_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"Boolean expression to filter rows from the table \"Album\". All fields are combined with a logical 'AND'." +input Album_bool_exp { + AlbumId: Int_comparison_exp + Artist: Artist_bool_exp + ArtistId: Int_comparison_exp + Title: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [Album_bool_exp!] + _not: Album_bool_exp + _or: [Album_bool_exp!] +} + +"unique or primary key constraints on table \"Album\"" +enum Album_constraint { + "unique or primary key constraint on columns \"AlbumId\"" PK_Album +} + +"input type for incrementing numeric columns in table \"Album\"" +input Album_inc_input { + ArtistId: Int +} + +"input type for inserting data into table \"Album\"" +input Album_insert_input { + Artist: Artist_obj_rel_insert_input + ArtistId: Int + Title: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type Album_max_fields { + AlbumId: Int + ArtistId: Int + Title: String +} + +"order by max() on columns of table \"Album\"" +input Album_max_order_by { + AlbumId: order_by + ArtistId: order_by + Title: order_by +} + +"aggregate min on columns" +type Album_min_fields { + AlbumId: Int + ArtistId: Int + Title: String +} + +"order by min() on columns of table \"Album\"" +input Album_min_order_by { + AlbumId: order_by + ArtistId: order_by + Title: order_by +} + +"response of any mutation on the table \"Album\"" +type Album_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Album!]! +} + +"input type for inserting object relation for remote table \"Album\"" +input Album_obj_rel_insert_input { + data: Album_insert_input! + "upsert condition" on_conflict: Album_on_conflict +} + +"on_conflict condition type for table \"Album\"" +input Album_on_conflict { + constraint: Album_constraint! + update_columns: [Album_update_column!]! = [] + where: Album_bool_exp +} + +"Ordering options when selecting data from \"Album\"." +input Album_order_by { + AlbumId: order_by + Artist: Artist_order_by + ArtistId: order_by + Title: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: Album" +input Album_pk_columns_input { + AlbumId: Int! +} + +"select columns of table \"Album\"" +enum Album_select_column { + "column name" AlbumId + "column name" ArtistId + "column name" Title +} + +"input type for updating data in table \"Album\"" +input Album_set_input { + ArtistId: Int + Title: String +} + +"aggregate stddev on columns" +type Album_stddev_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev() on columns of table \"Album\"" +input Album_stddev_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate stddev_pop on columns" +type Album_stddev_pop_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev_pop() on columns of table \"Album\"" +input Album_stddev_pop_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate stddev_samp on columns" +type Album_stddev_samp_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev_samp() on columns of table \"Album\"" +input Album_stddev_samp_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"Streaming cursor of the table \"Album\"" +input Album_stream_cursor_input { + "Stream column input with initial value" initial_value: Album_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Album_stream_cursor_value_input { + AlbumId: Int + ArtistId: Int + Title: String +} + +"aggregate sum on columns" +type Album_sum_fields { + AlbumId: Int + ArtistId: Int +} + +"order by sum() on columns of table \"Album\"" +input Album_sum_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"update columns of table \"Album\"" +enum Album_update_column { + "column name" ArtistId + "column name" Title +} + +input Album_updates { + "increments the numeric columns with given value of the filtered values" _inc: Album_inc_input + "sets the columns of the filtered rows to the given values" _set: Album_set_input + "filter the rows which have to be updated" where: Album_bool_exp! +} + +"aggregate var_pop on columns" +type Album_var_pop_fields { + AlbumId: Float + ArtistId: Float +} + +"order by var_pop() on columns of table \"Album\"" +input Album_var_pop_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate var_samp on columns" +type Album_var_samp_fields { + AlbumId: Float + ArtistId: Float +} + +"order by var_samp() on columns of table \"Album\"" +input Album_var_samp_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate variance on columns" +type Album_variance_fields { + AlbumId: Float + ArtistId: Float +} + +"order by variance() on columns of table \"Album\"" +input Album_variance_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"columns and relationships of \"Artist\"" +type Artist { + "An array relationship" + Albums("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "An aggregate relationship" + Albums_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + ArtistId: Int! + Name: String +} + +"aggregated selection of \"Artist\"" +type Artist_aggregate { + aggregate: Artist_aggregate_fields + nodes: [Artist!]! +} + +"aggregate fields of \"Artist\"" +type Artist_aggregate_fields { + avg: Artist_avg_fields + count(columns: [Artist_select_column!], distinct: Boolean): Int! + max: Artist_max_fields + min: Artist_min_fields + stddev: Artist_stddev_fields + stddev_pop: Artist_stddev_pop_fields + stddev_samp: Artist_stddev_samp_fields + sum: Artist_sum_fields + var_pop: Artist_var_pop_fields + var_samp: Artist_var_samp_fields + variance: Artist_variance_fields +} + +"aggregate avg on columns" +type Artist_avg_fields { + ArtistId: Float +} + +"Boolean expression to filter rows from the table \"Artist\". All fields are combined with a logical 'AND'." +input Artist_bool_exp { + Albums: Album_bool_exp + Albums_aggregate: Album_aggregate_bool_exp + ArtistId: Int_comparison_exp + Name: String_comparison_exp + _and: [Artist_bool_exp!] + _not: Artist_bool_exp + _or: [Artist_bool_exp!] +} + +"unique or primary key constraints on table \"Artist\"" +enum Artist_constraint { + "unique or primary key constraint on columns \"ArtistId\"" PK_Artist +} + +"input type for inserting data into table \"Artist\"" +input Artist_insert_input { + Albums: Album_arr_rel_insert_input + Name: String +} + +"aggregate max on columns" +type Artist_max_fields { + ArtistId: Int + Name: String +} + +"aggregate min on columns" +type Artist_min_fields { + ArtistId: Int + Name: String +} + +"response of any mutation on the table \"Artist\"" +type Artist_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Artist!]! +} + +"input type for inserting object relation for remote table \"Artist\"" +input Artist_obj_rel_insert_input { + data: Artist_insert_input! + "upsert condition" on_conflict: Artist_on_conflict +} + +"on_conflict condition type for table \"Artist\"" +input Artist_on_conflict { + constraint: Artist_constraint! + update_columns: [Artist_update_column!]! = [] + where: Artist_bool_exp +} + +"Ordering options when selecting data from \"Artist\"." +input Artist_order_by { + Albums_aggregate: Album_aggregate_order_by + ArtistId: order_by + Name: order_by +} + +"primary key columns input for table: Artist" +input Artist_pk_columns_input { + ArtistId: Int! +} + +"select columns of table \"Artist\"" +enum Artist_select_column { + "column name" ArtistId + "column name" Name +} + +"input type for updating data in table \"Artist\"" +input Artist_set_input { + Name: String +} + +"aggregate stddev on columns" +type Artist_stddev_fields { + ArtistId: Float +} + +"aggregate stddev_pop on columns" +type Artist_stddev_pop_fields { + ArtistId: Float +} + +"aggregate stddev_samp on columns" +type Artist_stddev_samp_fields { + ArtistId: Float +} + +"Streaming cursor of the table \"Artist\"" +input Artist_stream_cursor_input { + "Stream column input with initial value" initial_value: Artist_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Artist_stream_cursor_value_input { + ArtistId: Int + Name: String +} + +"aggregate sum on columns" +type Artist_sum_fields { + ArtistId: Int +} + +"update columns of table \"Artist\"" +enum Artist_update_column { + "column name" Name +} + +input Artist_updates { + "sets the columns of the filtered rows to the given values" _set: Artist_set_input + "filter the rows which have to be updated" where: Artist_bool_exp! +} + +"aggregate var_pop on columns" +type Artist_var_pop_fields { + ArtistId: Float +} + +"aggregate var_samp on columns" +type Artist_var_samp_fields { + ArtistId: Float +} + +"aggregate variance on columns" +type Artist_variance_fields { + ArtistId: Float +} + +scalar Boolean + +"columns and relationships of \"Customer\"" +type Customer { + Address: String + City: String + Company: String + Country: String + CustomerId: Int! + Email: String! + "An object relationship" + Employee: Employee + Fax: String + FirstName: String! + "An array relationship" + Invoices("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "An aggregate relationship" + Invoices_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + LastName: String! + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregated selection of \"Customer\"" +type Customer_aggregate { + aggregate: Customer_aggregate_fields + nodes: [Customer!]! +} + +input Customer_aggregate_bool_exp { + count: Customer_aggregate_bool_exp_count +} + +input Customer_aggregate_bool_exp_count { + arguments: [Customer_select_column!] + distinct: Boolean + filter: Customer_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Customer\"" +type Customer_aggregate_fields { + avg: Customer_avg_fields + count(columns: [Customer_select_column!], distinct: Boolean): Int! + max: Customer_max_fields + min: Customer_min_fields + stddev: Customer_stddev_fields + stddev_pop: Customer_stddev_pop_fields + stddev_samp: Customer_stddev_samp_fields + sum: Customer_sum_fields + var_pop: Customer_var_pop_fields + var_samp: Customer_var_samp_fields + variance: Customer_variance_fields +} + +"order by aggregate values of table \"Customer\"" +input Customer_aggregate_order_by { + avg: Customer_avg_order_by + count: order_by + max: Customer_max_order_by + min: Customer_min_order_by + stddev: Customer_stddev_order_by + stddev_pop: Customer_stddev_pop_order_by + stddev_samp: Customer_stddev_samp_order_by + sum: Customer_sum_order_by + var_pop: Customer_var_pop_order_by + var_samp: Customer_var_samp_order_by + variance: Customer_variance_order_by +} + +"input type for inserting array relation for remote table \"Customer\"" +input Customer_arr_rel_insert_input { + data: [Customer_insert_input!]! + "upsert condition" on_conflict: Customer_on_conflict +} + +"aggregate avg on columns" +type Customer_avg_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by avg() on columns of table \"Customer\"" +input Customer_avg_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"Boolean expression to filter rows from the table \"Customer\". All fields are combined with a logical 'AND'." +input Customer_bool_exp { + Address: String_comparison_exp + City: String_comparison_exp + Company: String_comparison_exp + Country: String_comparison_exp + CustomerId: Int_comparison_exp + Email: String_comparison_exp + Employee: Employee_bool_exp + Fax: String_comparison_exp + FirstName: String_comparison_exp + Invoices: Invoice_bool_exp + Invoices_aggregate: Invoice_aggregate_bool_exp + LastName: String_comparison_exp + Phone: String_comparison_exp + PostalCode: String_comparison_exp + State: String_comparison_exp + SupportRepId: Int_comparison_exp + _and: [Customer_bool_exp!] + _not: Customer_bool_exp + _or: [Customer_bool_exp!] +} + +"unique or primary key constraints on table \"Customer\"" +enum Customer_constraint { + "unique or primary key constraint on columns \"CustomerId\"" PK_Customer +} + +"input type for incrementing numeric columns in table \"Customer\"" +input Customer_inc_input { + SupportRepId: Int +} + +"input type for inserting data into table \"Customer\"" +input Customer_insert_input { + Address: String + City: String + Company: String + Country: String + Email: String + Employee: Employee_obj_rel_insert_input + Fax: String + FirstName: String + Invoices: Invoice_arr_rel_insert_input + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate max on columns" +type Customer_max_fields { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"order by max() on columns of table \"Customer\"" +input Customer_max_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Fax: order_by + FirstName: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"aggregate min on columns" +type Customer_min_fields { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"order by min() on columns of table \"Customer\"" +input Customer_min_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Fax: order_by + FirstName: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"response of any mutation on the table \"Customer\"" +type Customer_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Customer!]! +} + +"input type for inserting object relation for remote table \"Customer\"" +input Customer_obj_rel_insert_input { + data: Customer_insert_input! + "upsert condition" on_conflict: Customer_on_conflict +} + +"on_conflict condition type for table \"Customer\"" +input Customer_on_conflict { + constraint: Customer_constraint! + update_columns: [Customer_update_column!]! = [] + where: Customer_bool_exp +} + +"Ordering options when selecting data from \"Customer\"." +input Customer_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Employee: Employee_order_by + Fax: order_by + FirstName: order_by + Invoices_aggregate: Invoice_aggregate_order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"primary key columns input for table: Customer" +input Customer_pk_columns_input { + CustomerId: Int! +} + +"select columns of table \"Customer\"" +enum Customer_select_column { + "column name" Address + "column name" City + "column name" Company + "column name" Country + "column name" CustomerId + "column name" Email + "column name" Fax + "column name" FirstName + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" State + "column name" SupportRepId +} + +"input type for updating data in table \"Customer\"" +input Customer_set_input { + Address: String + City: String + Company: String + Country: String + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate stddev on columns" +type Customer_stddev_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev() on columns of table \"Customer\"" +input Customer_stddev_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate stddev_pop on columns" +type Customer_stddev_pop_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev_pop() on columns of table \"Customer\"" +input Customer_stddev_pop_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate stddev_samp on columns" +type Customer_stddev_samp_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev_samp() on columns of table \"Customer\"" +input Customer_stddev_samp_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"Streaming cursor of the table \"Customer\"" +input Customer_stream_cursor_input { + "Stream column input with initial value" initial_value: Customer_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Customer_stream_cursor_value_input { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate sum on columns" +type Customer_sum_fields { + CustomerId: Int + SupportRepId: Int +} + +"order by sum() on columns of table \"Customer\"" +input Customer_sum_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"update columns of table \"Customer\"" +enum Customer_update_column { + "column name" Address + "column name" City + "column name" Company + "column name" Country + "column name" Email + "column name" Fax + "column name" FirstName + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" State + "column name" SupportRepId +} + +input Customer_updates { + "increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input + "sets the columns of the filtered rows to the given values" _set: Customer_set_input + "filter the rows which have to be updated" where: Customer_bool_exp! +} + +"aggregate var_pop on columns" +type Customer_var_pop_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by var_pop() on columns of table \"Customer\"" +input Customer_var_pop_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate var_samp on columns" +type Customer_var_samp_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by var_samp() on columns of table \"Customer\"" +input Customer_var_samp_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate variance on columns" +type Customer_variance_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by variance() on columns of table \"Customer\"" +input Customer_variance_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"columns and relationships of \"Employee\"" +type Employee { + Address: String + BirthDate: timestamp + City: String + Country: String + "An array relationship" + Customers("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "An aggregate relationship" + Customers_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + Email: String + "An object relationship" + Employee: Employee + EmployeeId: Int! + "An array relationship" + Employees("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "An aggregate relationship" + Employees_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + Fax: String + FirstName: String! + HireDate: timestamp + LastName: String! + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregated selection of \"Employee\"" +type Employee_aggregate { + aggregate: Employee_aggregate_fields + nodes: [Employee!]! +} + +input Employee_aggregate_bool_exp { + count: Employee_aggregate_bool_exp_count +} + +input Employee_aggregate_bool_exp_count { + arguments: [Employee_select_column!] + distinct: Boolean + filter: Employee_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Employee\"" +type Employee_aggregate_fields { + avg: Employee_avg_fields + count(columns: [Employee_select_column!], distinct: Boolean): Int! + max: Employee_max_fields + min: Employee_min_fields + stddev: Employee_stddev_fields + stddev_pop: Employee_stddev_pop_fields + stddev_samp: Employee_stddev_samp_fields + sum: Employee_sum_fields + var_pop: Employee_var_pop_fields + var_samp: Employee_var_samp_fields + variance: Employee_variance_fields +} + +"order by aggregate values of table \"Employee\"" +input Employee_aggregate_order_by { + avg: Employee_avg_order_by + count: order_by + max: Employee_max_order_by + min: Employee_min_order_by + stddev: Employee_stddev_order_by + stddev_pop: Employee_stddev_pop_order_by + stddev_samp: Employee_stddev_samp_order_by + sum: Employee_sum_order_by + var_pop: Employee_var_pop_order_by + var_samp: Employee_var_samp_order_by + variance: Employee_variance_order_by +} + +"input type for inserting array relation for remote table \"Employee\"" +input Employee_arr_rel_insert_input { + data: [Employee_insert_input!]! + "upsert condition" on_conflict: Employee_on_conflict +} + +"aggregate avg on columns" +type Employee_avg_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by avg() on columns of table \"Employee\"" +input Employee_avg_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"Boolean expression to filter rows from the table \"Employee\". All fields are combined with a logical 'AND'." +input Employee_bool_exp { + Address: String_comparison_exp + BirthDate: timestamp_comparison_exp + City: String_comparison_exp + Country: String_comparison_exp + Customers: Customer_bool_exp + Customers_aggregate: Customer_aggregate_bool_exp + Email: String_comparison_exp + Employee: Employee_bool_exp + EmployeeId: Int_comparison_exp + Employees: Employee_bool_exp + Employees_aggregate: Employee_aggregate_bool_exp + Fax: String_comparison_exp + FirstName: String_comparison_exp + HireDate: timestamp_comparison_exp + LastName: String_comparison_exp + Phone: String_comparison_exp + PostalCode: String_comparison_exp + ReportsTo: Int_comparison_exp + State: String_comparison_exp + Title: String_comparison_exp + _and: [Employee_bool_exp!] + _not: Employee_bool_exp + _or: [Employee_bool_exp!] +} + +"unique or primary key constraints on table \"Employee\"" +enum Employee_constraint { + "unique or primary key constraint on columns \"EmployeeId\"" PK_Employee +} + +"input type for incrementing numeric columns in table \"Employee\"" +input Employee_inc_input { + ReportsTo: Int +} + +"input type for inserting data into table \"Employee\"" +input Employee_insert_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Customers: Customer_arr_rel_insert_input + Email: String + Employee: Employee_obj_rel_insert_input + Employees: Employee_arr_rel_insert_input + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate max on columns" +type Employee_max_fields { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"order by max() on columns of table \"Employee\"" +input Employee_max_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Email: order_by + EmployeeId: order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"aggregate min on columns" +type Employee_min_fields { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"order by min() on columns of table \"Employee\"" +input Employee_min_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Email: order_by + EmployeeId: order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"response of any mutation on the table \"Employee\"" +type Employee_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Employee!]! +} + +"input type for inserting object relation for remote table \"Employee\"" +input Employee_obj_rel_insert_input { + data: Employee_insert_input! + "upsert condition" on_conflict: Employee_on_conflict +} + +"on_conflict condition type for table \"Employee\"" +input Employee_on_conflict { + constraint: Employee_constraint! + update_columns: [Employee_update_column!]! = [] + where: Employee_bool_exp +} + +"Ordering options when selecting data from \"Employee\"." +input Employee_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Customers_aggregate: Customer_aggregate_order_by + Email: order_by + Employee: Employee_order_by + EmployeeId: order_by + Employees_aggregate: Employee_aggregate_order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"primary key columns input for table: Employee" +input Employee_pk_columns_input { + EmployeeId: Int! +} + +"select columns of table \"Employee\"" +enum Employee_select_column { + "column name" Address + "column name" BirthDate + "column name" City + "column name" Country + "column name" Email + "column name" EmployeeId + "column name" Fax + "column name" FirstName + "column name" HireDate + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" ReportsTo + "column name" State + "column name" Title +} + +"input type for updating data in table \"Employee\"" +input Employee_set_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate stddev on columns" +type Employee_stddev_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev() on columns of table \"Employee\"" +input Employee_stddev_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate stddev_pop on columns" +type Employee_stddev_pop_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev_pop() on columns of table \"Employee\"" +input Employee_stddev_pop_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate stddev_samp on columns" +type Employee_stddev_samp_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev_samp() on columns of table \"Employee\"" +input Employee_stddev_samp_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"Streaming cursor of the table \"Employee\"" +input Employee_stream_cursor_input { + "Stream column input with initial value" initial_value: Employee_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Employee_stream_cursor_value_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate sum on columns" +type Employee_sum_fields { + EmployeeId: Int + ReportsTo: Int +} + +"order by sum() on columns of table \"Employee\"" +input Employee_sum_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"update columns of table \"Employee\"" +enum Employee_update_column { + "column name" Address + "column name" BirthDate + "column name" City + "column name" Country + "column name" Email + "column name" Fax + "column name" FirstName + "column name" HireDate + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" ReportsTo + "column name" State + "column name" Title +} + +input Employee_updates { + "increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input + "sets the columns of the filtered rows to the given values" _set: Employee_set_input + "filter the rows which have to be updated" where: Employee_bool_exp! +} + +"aggregate var_pop on columns" +type Employee_var_pop_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by var_pop() on columns of table \"Employee\"" +input Employee_var_pop_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate var_samp on columns" +type Employee_var_samp_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by var_samp() on columns of table \"Employee\"" +input Employee_var_samp_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate variance on columns" +type Employee_variance_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by variance() on columns of table \"Employee\"" +input Employee_variance_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +scalar Float + +"columns and relationships of \"Genre\"" +type Genre { + GenreId: Int! + Name: String + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"Genre\"" +type Genre_aggregate { + aggregate: Genre_aggregate_fields + nodes: [Genre!]! +} + +"aggregate fields of \"Genre\"" +type Genre_aggregate_fields { + avg: Genre_avg_fields + count(columns: [Genre_select_column!], distinct: Boolean): Int! + max: Genre_max_fields + min: Genre_min_fields + stddev: Genre_stddev_fields + stddev_pop: Genre_stddev_pop_fields + stddev_samp: Genre_stddev_samp_fields + sum: Genre_sum_fields + var_pop: Genre_var_pop_fields + var_samp: Genre_var_samp_fields + variance: Genre_variance_fields +} + +"aggregate avg on columns" +type Genre_avg_fields { + GenreId: Float +} + +"Boolean expression to filter rows from the table \"Genre\". All fields are combined with a logical 'AND'." +input Genre_bool_exp { + GenreId: Int_comparison_exp + Name: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [Genre_bool_exp!] + _not: Genre_bool_exp + _or: [Genre_bool_exp!] +} + +"unique or primary key constraints on table \"Genre\"" +enum Genre_constraint { + "unique or primary key constraint on columns \"GenreId\"" PK_Genre +} + +"input type for inserting data into table \"Genre\"" +input Genre_insert_input { + Name: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type Genre_max_fields { + GenreId: Int + Name: String +} + +"aggregate min on columns" +type Genre_min_fields { + GenreId: Int + Name: String +} + +"response of any mutation on the table \"Genre\"" +type Genre_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Genre!]! +} + +"input type for inserting object relation for remote table \"Genre\"" +input Genre_obj_rel_insert_input { + data: Genre_insert_input! + "upsert condition" on_conflict: Genre_on_conflict +} + +"on_conflict condition type for table \"Genre\"" +input Genre_on_conflict { + constraint: Genre_constraint! + update_columns: [Genre_update_column!]! = [] + where: Genre_bool_exp +} + +"Ordering options when selecting data from \"Genre\"." +input Genre_order_by { + GenreId: order_by + Name: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: Genre" +input Genre_pk_columns_input { + GenreId: Int! +} + +"select columns of table \"Genre\"" +enum Genre_select_column { + "column name" GenreId + "column name" Name +} + +"input type for updating data in table \"Genre\"" +input Genre_set_input { + Name: String +} + +"aggregate stddev on columns" +type Genre_stddev_fields { + GenreId: Float +} + +"aggregate stddev_pop on columns" +type Genre_stddev_pop_fields { + GenreId: Float +} + +"aggregate stddev_samp on columns" +type Genre_stddev_samp_fields { + GenreId: Float +} + +"Streaming cursor of the table \"Genre\"" +input Genre_stream_cursor_input { + "Stream column input with initial value" initial_value: Genre_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Genre_stream_cursor_value_input { + GenreId: Int + Name: String +} + +"aggregate sum on columns" +type Genre_sum_fields { + GenreId: Int +} + +"update columns of table \"Genre\"" +enum Genre_update_column { + "column name" Name +} + +input Genre_updates { + "sets the columns of the filtered rows to the given values" _set: Genre_set_input + "filter the rows which have to be updated" where: Genre_bool_exp! +} + +"aggregate var_pop on columns" +type Genre_var_pop_fields { + GenreId: Float +} + +"aggregate var_samp on columns" +type Genre_var_samp_fields { + GenreId: Float +} + +"aggregate variance on columns" +type Genre_variance_fields { + GenreId: Float +} + +scalar Int + +"Boolean expression to compare columns of type \"Int\". All fields are combined with logical 'AND'." +input Int_comparison_exp { + _eq: Int + _gt: Int + _gte: Int + _in: [Int!] + _is_null: Boolean + _lt: Int + _lte: Int + _neq: Int + _nin: [Int!] +} + +"columns and relationships of \"Invoice\"" +type Invoice { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + "An object relationship" + Customer: Customer! + CustomerId: Int! + InvoiceDate: timestamp! + InvoiceId: Int! + "An array relationship" + InvoiceLines("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "An aggregate relationship" + InvoiceLines_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + Total: numeric! +} + +"columns and relationships of \"InvoiceLine\"" +type InvoiceLine { + "An object relationship" + Invoice: Invoice! + InvoiceId: Int! + InvoiceLineId: Int! + Quantity: Int! + "An object relationship" + Track: Track! + TrackId: Int! + UnitPrice: numeric! +} + +"aggregated selection of \"InvoiceLine\"" +type InvoiceLine_aggregate { + aggregate: InvoiceLine_aggregate_fields + nodes: [InvoiceLine!]! +} + +input InvoiceLine_aggregate_bool_exp { + count: InvoiceLine_aggregate_bool_exp_count +} + +input InvoiceLine_aggregate_bool_exp_count { + arguments: [InvoiceLine_select_column!] + distinct: Boolean + filter: InvoiceLine_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"InvoiceLine\"" +type InvoiceLine_aggregate_fields { + avg: InvoiceLine_avg_fields + count(columns: [InvoiceLine_select_column!], distinct: Boolean): Int! + max: InvoiceLine_max_fields + min: InvoiceLine_min_fields + stddev: InvoiceLine_stddev_fields + stddev_pop: InvoiceLine_stddev_pop_fields + stddev_samp: InvoiceLine_stddev_samp_fields + sum: InvoiceLine_sum_fields + var_pop: InvoiceLine_var_pop_fields + var_samp: InvoiceLine_var_samp_fields + variance: InvoiceLine_variance_fields +} + +"order by aggregate values of table \"InvoiceLine\"" +input InvoiceLine_aggregate_order_by { + avg: InvoiceLine_avg_order_by + count: order_by + max: InvoiceLine_max_order_by + min: InvoiceLine_min_order_by + stddev: InvoiceLine_stddev_order_by + stddev_pop: InvoiceLine_stddev_pop_order_by + stddev_samp: InvoiceLine_stddev_samp_order_by + sum: InvoiceLine_sum_order_by + var_pop: InvoiceLine_var_pop_order_by + var_samp: InvoiceLine_var_samp_order_by + variance: InvoiceLine_variance_order_by +} + +"input type for inserting array relation for remote table \"InvoiceLine\"" +input InvoiceLine_arr_rel_insert_input { + data: [InvoiceLine_insert_input!]! + "upsert condition" on_conflict: InvoiceLine_on_conflict +} + +"aggregate avg on columns" +type InvoiceLine_avg_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by avg() on columns of table \"InvoiceLine\"" +input InvoiceLine_avg_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Boolean expression to filter rows from the table \"InvoiceLine\". All fields are combined with a logical 'AND'." +input InvoiceLine_bool_exp { + Invoice: Invoice_bool_exp + InvoiceId: Int_comparison_exp + InvoiceLineId: Int_comparison_exp + Quantity: Int_comparison_exp + Track: Track_bool_exp + TrackId: Int_comparison_exp + UnitPrice: numeric_comparison_exp + _and: [InvoiceLine_bool_exp!] + _not: InvoiceLine_bool_exp + _or: [InvoiceLine_bool_exp!] +} + +"unique or primary key constraints on table \"InvoiceLine\"" +enum InvoiceLine_constraint { + "unique or primary key constraint on columns \"InvoiceLineId\"" PK_InvoiceLine +} + +"input type for incrementing numeric columns in table \"InvoiceLine\"" +input InvoiceLine_inc_input { + InvoiceId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"input type for inserting data into table \"InvoiceLine\"" +input InvoiceLine_insert_input { + Invoice: Invoice_obj_rel_insert_input + InvoiceId: Int + Quantity: Int + Track: Track_obj_rel_insert_input + TrackId: Int + UnitPrice: numeric +} + +"aggregate max on columns" +type InvoiceLine_max_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by max() on columns of table \"InvoiceLine\"" +input InvoiceLine_max_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate min on columns" +type InvoiceLine_min_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by min() on columns of table \"InvoiceLine\"" +input InvoiceLine_min_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"response of any mutation on the table \"InvoiceLine\"" +type InvoiceLine_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [InvoiceLine!]! +} + +"on_conflict condition type for table \"InvoiceLine\"" +input InvoiceLine_on_conflict { + constraint: InvoiceLine_constraint! + update_columns: [InvoiceLine_update_column!]! = [] + where: InvoiceLine_bool_exp +} + +"Ordering options when selecting data from \"InvoiceLine\"." +input InvoiceLine_order_by { + Invoice: Invoice_order_by + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + Track: Track_order_by + TrackId: order_by + UnitPrice: order_by +} + +"primary key columns input for table: InvoiceLine" +input InvoiceLine_pk_columns_input { + InvoiceLineId: Int! +} + +"select columns of table \"InvoiceLine\"" +enum InvoiceLine_select_column { + "column name" InvoiceId + "column name" InvoiceLineId + "column name" Quantity + "column name" TrackId + "column name" UnitPrice +} + +"input type for updating data in table \"InvoiceLine\"" +input InvoiceLine_set_input { + InvoiceId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"aggregate stddev on columns" +type InvoiceLine_stddev_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_pop on columns" +type InvoiceLine_stddev_pop_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_pop() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_pop_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_samp on columns" +type InvoiceLine_stddev_samp_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_samp() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_samp_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Streaming cursor of the table \"InvoiceLine\"" +input InvoiceLine_stream_cursor_input { + "Stream column input with initial value" initial_value: InvoiceLine_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input InvoiceLine_stream_cursor_value_input { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"aggregate sum on columns" +type InvoiceLine_sum_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by sum() on columns of table \"InvoiceLine\"" +input InvoiceLine_sum_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"update columns of table \"InvoiceLine\"" +enum InvoiceLine_update_column { + "column name" InvoiceId + "column name" Quantity + "column name" TrackId + "column name" UnitPrice +} + +input InvoiceLine_updates { + "increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input + "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input + "filter the rows which have to be updated" where: InvoiceLine_bool_exp! +} + +"aggregate var_pop on columns" +type InvoiceLine_var_pop_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_pop() on columns of table \"InvoiceLine\"" +input InvoiceLine_var_pop_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate var_samp on columns" +type InvoiceLine_var_samp_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_samp() on columns of table \"InvoiceLine\"" +input InvoiceLine_var_samp_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate variance on columns" +type InvoiceLine_variance_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by variance() on columns of table \"InvoiceLine\"" +input InvoiceLine_variance_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregated selection of \"Invoice\"" +type Invoice_aggregate { + aggregate: Invoice_aggregate_fields + nodes: [Invoice!]! +} + +input Invoice_aggregate_bool_exp { + count: Invoice_aggregate_bool_exp_count +} + +input Invoice_aggregate_bool_exp_count { + arguments: [Invoice_select_column!] + distinct: Boolean + filter: Invoice_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Invoice\"" +type Invoice_aggregate_fields { + avg: Invoice_avg_fields + count(columns: [Invoice_select_column!], distinct: Boolean): Int! + max: Invoice_max_fields + min: Invoice_min_fields + stddev: Invoice_stddev_fields + stddev_pop: Invoice_stddev_pop_fields + stddev_samp: Invoice_stddev_samp_fields + sum: Invoice_sum_fields + var_pop: Invoice_var_pop_fields + var_samp: Invoice_var_samp_fields + variance: Invoice_variance_fields +} + +"order by aggregate values of table \"Invoice\"" +input Invoice_aggregate_order_by { + avg: Invoice_avg_order_by + count: order_by + max: Invoice_max_order_by + min: Invoice_min_order_by + stddev: Invoice_stddev_order_by + stddev_pop: Invoice_stddev_pop_order_by + stddev_samp: Invoice_stddev_samp_order_by + sum: Invoice_sum_order_by + var_pop: Invoice_var_pop_order_by + var_samp: Invoice_var_samp_order_by + variance: Invoice_variance_order_by +} + +"input type for inserting array relation for remote table \"Invoice\"" +input Invoice_arr_rel_insert_input { + data: [Invoice_insert_input!]! + "upsert condition" on_conflict: Invoice_on_conflict +} + +"aggregate avg on columns" +type Invoice_avg_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by avg() on columns of table \"Invoice\"" +input Invoice_avg_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"Boolean expression to filter rows from the table \"Invoice\". All fields are combined with a logical 'AND'." +input Invoice_bool_exp { + BillingAddress: String_comparison_exp + BillingCity: String_comparison_exp + BillingCountry: String_comparison_exp + BillingPostalCode: String_comparison_exp + BillingState: String_comparison_exp + Customer: Customer_bool_exp + CustomerId: Int_comparison_exp + InvoiceDate: timestamp_comparison_exp + InvoiceId: Int_comparison_exp + InvoiceLines: InvoiceLine_bool_exp + InvoiceLines_aggregate: InvoiceLine_aggregate_bool_exp + Total: numeric_comparison_exp + _and: [Invoice_bool_exp!] + _not: Invoice_bool_exp + _or: [Invoice_bool_exp!] +} + +"unique or primary key constraints on table \"Invoice\"" +enum Invoice_constraint { + "unique or primary key constraint on columns \"InvoiceId\"" PK_Invoice +} + +"input type for incrementing numeric columns in table \"Invoice\"" +input Invoice_inc_input { + CustomerId: Int + Total: numeric +} + +"input type for inserting data into table \"Invoice\"" +input Invoice_insert_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + Customer: Customer_obj_rel_insert_input + CustomerId: Int + InvoiceDate: timestamp + InvoiceLines: InvoiceLine_arr_rel_insert_input + Total: numeric +} + +"aggregate max on columns" +type Invoice_max_fields { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"order by max() on columns of table \"Invoice\"" +input Invoice_max_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate min on columns" +type Invoice_min_fields { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"order by min() on columns of table \"Invoice\"" +input Invoice_min_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + Total: order_by +} + +"response of any mutation on the table \"Invoice\"" +type Invoice_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Invoice!]! +} + +"input type for inserting object relation for remote table \"Invoice\"" +input Invoice_obj_rel_insert_input { + data: Invoice_insert_input! + "upsert condition" on_conflict: Invoice_on_conflict +} + +"on_conflict condition type for table \"Invoice\"" +input Invoice_on_conflict { + constraint: Invoice_constraint! + update_columns: [Invoice_update_column!]! = [] + where: Invoice_bool_exp +} + +"Ordering options when selecting data from \"Invoice\"." +input Invoice_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + Customer: Customer_order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + InvoiceLines_aggregate: InvoiceLine_aggregate_order_by + Total: order_by +} + +"primary key columns input for table: Invoice" +input Invoice_pk_columns_input { + InvoiceId: Int! +} + +"select columns of table \"Invoice\"" +enum Invoice_select_column { + "column name" BillingAddress + "column name" BillingCity + "column name" BillingCountry + "column name" BillingPostalCode + "column name" BillingState + "column name" CustomerId + "column name" InvoiceDate + "column name" InvoiceId + "column name" Total +} + +"input type for updating data in table \"Invoice\"" +input Invoice_set_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + Total: numeric +} + +"aggregate stddev on columns" +type Invoice_stddev_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev() on columns of table \"Invoice\"" +input Invoice_stddev_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate stddev_pop on columns" +type Invoice_stddev_pop_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev_pop() on columns of table \"Invoice\"" +input Invoice_stddev_pop_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate stddev_samp on columns" +type Invoice_stddev_samp_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev_samp() on columns of table \"Invoice\"" +input Invoice_stddev_samp_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"Streaming cursor of the table \"Invoice\"" +input Invoice_stream_cursor_input { + "Stream column input with initial value" initial_value: Invoice_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Invoice_stream_cursor_value_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"aggregate sum on columns" +type Invoice_sum_fields { + CustomerId: Int + InvoiceId: Int + Total: numeric +} + +"order by sum() on columns of table \"Invoice\"" +input Invoice_sum_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"update columns of table \"Invoice\"" +enum Invoice_update_column { + "column name" BillingAddress + "column name" BillingCity + "column name" BillingCountry + "column name" BillingPostalCode + "column name" BillingState + "column name" CustomerId + "column name" InvoiceDate + "column name" Total +} + +input Invoice_updates { + "increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input + "sets the columns of the filtered rows to the given values" _set: Invoice_set_input + "filter the rows which have to be updated" where: Invoice_bool_exp! +} + +"aggregate var_pop on columns" +type Invoice_var_pop_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by var_pop() on columns of table \"Invoice\"" +input Invoice_var_pop_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate var_samp on columns" +type Invoice_var_samp_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by var_samp() on columns of table \"Invoice\"" +input Invoice_var_samp_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate variance on columns" +type Invoice_variance_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by variance() on columns of table \"Invoice\"" +input Invoice_variance_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"columns and relationships of \"MediaType\"" +type MediaType { + MediaTypeId: Int! + Name: String + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"MediaType\"" +type MediaType_aggregate { + aggregate: MediaType_aggregate_fields + nodes: [MediaType!]! +} + +"aggregate fields of \"MediaType\"" +type MediaType_aggregate_fields { + avg: MediaType_avg_fields + count(columns: [MediaType_select_column!], distinct: Boolean): Int! + max: MediaType_max_fields + min: MediaType_min_fields + stddev: MediaType_stddev_fields + stddev_pop: MediaType_stddev_pop_fields + stddev_samp: MediaType_stddev_samp_fields + sum: MediaType_sum_fields + var_pop: MediaType_var_pop_fields + var_samp: MediaType_var_samp_fields + variance: MediaType_variance_fields +} + +"aggregate avg on columns" +type MediaType_avg_fields { + MediaTypeId: Float +} + +"Boolean expression to filter rows from the table \"MediaType\". All fields are combined with a logical 'AND'." +input MediaType_bool_exp { + MediaTypeId: Int_comparison_exp + Name: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [MediaType_bool_exp!] + _not: MediaType_bool_exp + _or: [MediaType_bool_exp!] +} + +"unique or primary key constraints on table \"MediaType\"" +enum MediaType_constraint { + "unique or primary key constraint on columns \"MediaTypeId\"" PK_MediaType +} + +"input type for inserting data into table \"MediaType\"" +input MediaType_insert_input { + Name: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type MediaType_max_fields { + MediaTypeId: Int + Name: String +} + +"aggregate min on columns" +type MediaType_min_fields { + MediaTypeId: Int + Name: String +} + +"response of any mutation on the table \"MediaType\"" +type MediaType_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [MediaType!]! +} + +"input type for inserting object relation for remote table \"MediaType\"" +input MediaType_obj_rel_insert_input { + data: MediaType_insert_input! + "upsert condition" on_conflict: MediaType_on_conflict +} + +"on_conflict condition type for table \"MediaType\"" +input MediaType_on_conflict { + constraint: MediaType_constraint! + update_columns: [MediaType_update_column!]! = [] + where: MediaType_bool_exp +} + +"Ordering options when selecting data from \"MediaType\"." +input MediaType_order_by { + MediaTypeId: order_by + Name: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: MediaType" +input MediaType_pk_columns_input { + MediaTypeId: Int! +} + +"select columns of table \"MediaType\"" +enum MediaType_select_column { + "column name" MediaTypeId + "column name" Name +} + +"input type for updating data in table \"MediaType\"" +input MediaType_set_input { + Name: String +} + +"aggregate stddev on columns" +type MediaType_stddev_fields { + MediaTypeId: Float +} + +"aggregate stddev_pop on columns" +type MediaType_stddev_pop_fields { + MediaTypeId: Float +} + +"aggregate stddev_samp on columns" +type MediaType_stddev_samp_fields { + MediaTypeId: Float +} + +"Streaming cursor of the table \"MediaType\"" +input MediaType_stream_cursor_input { + "Stream column input with initial value" initial_value: MediaType_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input MediaType_stream_cursor_value_input { + MediaTypeId: Int + Name: String +} + +"aggregate sum on columns" +type MediaType_sum_fields { + MediaTypeId: Int +} + +"update columns of table \"MediaType\"" +enum MediaType_update_column { + "column name" Name +} + +input MediaType_updates { + "sets the columns of the filtered rows to the given values" _set: MediaType_set_input + "filter the rows which have to be updated" where: MediaType_bool_exp! +} + +"aggregate var_pop on columns" +type MediaType_var_pop_fields { + MediaTypeId: Float +} + +"aggregate var_samp on columns" +type MediaType_var_samp_fields { + MediaTypeId: Float +} + +"aggregate variance on columns" +type MediaType_variance_fields { + MediaTypeId: Float +} + +"columns and relationships of \"Playlist\"" +type Playlist { + Name: String + PlaylistId: Int! + "An array relationship" + PlaylistTracks("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "An aggregate relationship" + PlaylistTracks_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! +} + +"columns and relationships of \"PlaylistTrack\"" +type PlaylistTrack { + "An object relationship" + Playlist: Playlist! + PlaylistId: Int! + "An object relationship" + Track: Track! + TrackId: Int! +} + +"aggregated selection of \"PlaylistTrack\"" +type PlaylistTrack_aggregate { + aggregate: PlaylistTrack_aggregate_fields + nodes: [PlaylistTrack!]! +} + +input PlaylistTrack_aggregate_bool_exp { + count: PlaylistTrack_aggregate_bool_exp_count +} + +input PlaylistTrack_aggregate_bool_exp_count { + arguments: [PlaylistTrack_select_column!] + distinct: Boolean + filter: PlaylistTrack_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"PlaylistTrack\"" +type PlaylistTrack_aggregate_fields { + avg: PlaylistTrack_avg_fields + count(columns: [PlaylistTrack_select_column!], distinct: Boolean): Int! + max: PlaylistTrack_max_fields + min: PlaylistTrack_min_fields + stddev: PlaylistTrack_stddev_fields + stddev_pop: PlaylistTrack_stddev_pop_fields + stddev_samp: PlaylistTrack_stddev_samp_fields + sum: PlaylistTrack_sum_fields + var_pop: PlaylistTrack_var_pop_fields + var_samp: PlaylistTrack_var_samp_fields + variance: PlaylistTrack_variance_fields +} + +"order by aggregate values of table \"PlaylistTrack\"" +input PlaylistTrack_aggregate_order_by { + avg: PlaylistTrack_avg_order_by + count: order_by + max: PlaylistTrack_max_order_by + min: PlaylistTrack_min_order_by + stddev: PlaylistTrack_stddev_order_by + stddev_pop: PlaylistTrack_stddev_pop_order_by + stddev_samp: PlaylistTrack_stddev_samp_order_by + sum: PlaylistTrack_sum_order_by + var_pop: PlaylistTrack_var_pop_order_by + var_samp: PlaylistTrack_var_samp_order_by + variance: PlaylistTrack_variance_order_by +} + +"input type for inserting array relation for remote table \"PlaylistTrack\"" +input PlaylistTrack_arr_rel_insert_input { + data: [PlaylistTrack_insert_input!]! + "upsert condition" on_conflict: PlaylistTrack_on_conflict +} + +"aggregate avg on columns" +type PlaylistTrack_avg_fields { + PlaylistId: Float + TrackId: Float +} + +"order by avg() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_avg_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"Boolean expression to filter rows from the table \"PlaylistTrack\". All fields are combined with a logical 'AND'." +input PlaylistTrack_bool_exp { + Playlist: Playlist_bool_exp + PlaylistId: Int_comparison_exp + Track: Track_bool_exp + TrackId: Int_comparison_exp + _and: [PlaylistTrack_bool_exp!] + _not: PlaylistTrack_bool_exp + _or: [PlaylistTrack_bool_exp!] +} + +"unique or primary key constraints on table \"PlaylistTrack\"" +enum PlaylistTrack_constraint { + "unique or primary key constraint on columns \"TrackId\", \"PlaylistId\"" PK_PlaylistTrack +} + +"input type for incrementing numeric columns in table \"PlaylistTrack\"" +input PlaylistTrack_inc_input { + PlaylistId: Int + TrackId: Int +} + +"input type for inserting data into table \"PlaylistTrack\"" +input PlaylistTrack_insert_input { + Playlist: Playlist_obj_rel_insert_input + PlaylistId: Int + Track: Track_obj_rel_insert_input + TrackId: Int +} + +"aggregate max on columns" +type PlaylistTrack_max_fields { + PlaylistId: Int + TrackId: Int +} + +"order by max() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_max_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate min on columns" +type PlaylistTrack_min_fields { + PlaylistId: Int + TrackId: Int +} + +"order by min() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_min_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"response of any mutation on the table \"PlaylistTrack\"" +type PlaylistTrack_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [PlaylistTrack!]! +} + +"on_conflict condition type for table \"PlaylistTrack\"" +input PlaylistTrack_on_conflict { + constraint: PlaylistTrack_constraint! + update_columns: [PlaylistTrack_update_column!]! = [] + where: PlaylistTrack_bool_exp +} + +"Ordering options when selecting data from \"PlaylistTrack\"." +input PlaylistTrack_order_by { + Playlist: Playlist_order_by + PlaylistId: order_by + Track: Track_order_by + TrackId: order_by +} + +"primary key columns input for table: PlaylistTrack" +input PlaylistTrack_pk_columns_input { + PlaylistId: Int! + TrackId: Int! +} + +"select columns of table \"PlaylistTrack\"" +enum PlaylistTrack_select_column { + "column name" PlaylistId + "column name" TrackId +} + +"input type for updating data in table \"PlaylistTrack\"" +input PlaylistTrack_set_input { + PlaylistId: Int + TrackId: Int +} + +"aggregate stddev on columns" +type PlaylistTrack_stddev_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate stddev_pop on columns" +type PlaylistTrack_stddev_pop_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev_pop() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_pop_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate stddev_samp on columns" +type PlaylistTrack_stddev_samp_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev_samp() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_samp_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"Streaming cursor of the table \"PlaylistTrack\"" +input PlaylistTrack_stream_cursor_input { + "Stream column input with initial value" initial_value: PlaylistTrack_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input PlaylistTrack_stream_cursor_value_input { + PlaylistId: Int + TrackId: Int +} + +"aggregate sum on columns" +type PlaylistTrack_sum_fields { + PlaylistId: Int + TrackId: Int +} + +"order by sum() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_sum_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"update columns of table \"PlaylistTrack\"" +enum PlaylistTrack_update_column { + "column name" PlaylistId + "column name" TrackId +} + +input PlaylistTrack_updates { + "increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input + "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input + "filter the rows which have to be updated" where: PlaylistTrack_bool_exp! +} + +"aggregate var_pop on columns" +type PlaylistTrack_var_pop_fields { + PlaylistId: Float + TrackId: Float +} + +"order by var_pop() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_var_pop_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate var_samp on columns" +type PlaylistTrack_var_samp_fields { + PlaylistId: Float + TrackId: Float +} + +"order by var_samp() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_var_samp_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate variance on columns" +type PlaylistTrack_variance_fields { + PlaylistId: Float + TrackId: Float +} + +"order by variance() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_variance_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregated selection of \"Playlist\"" +type Playlist_aggregate { + aggregate: Playlist_aggregate_fields + nodes: [Playlist!]! +} + +"aggregate fields of \"Playlist\"" +type Playlist_aggregate_fields { + avg: Playlist_avg_fields + count(columns: [Playlist_select_column!], distinct: Boolean): Int! + max: Playlist_max_fields + min: Playlist_min_fields + stddev: Playlist_stddev_fields + stddev_pop: Playlist_stddev_pop_fields + stddev_samp: Playlist_stddev_samp_fields + sum: Playlist_sum_fields + var_pop: Playlist_var_pop_fields + var_samp: Playlist_var_samp_fields + variance: Playlist_variance_fields +} + +"aggregate avg on columns" +type Playlist_avg_fields { + PlaylistId: Float +} + +"Boolean expression to filter rows from the table \"Playlist\". All fields are combined with a logical 'AND'." +input Playlist_bool_exp { + Name: String_comparison_exp + PlaylistId: Int_comparison_exp + PlaylistTracks: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: PlaylistTrack_aggregate_bool_exp + _and: [Playlist_bool_exp!] + _not: Playlist_bool_exp + _or: [Playlist_bool_exp!] +} + +"unique or primary key constraints on table \"Playlist\"" +enum Playlist_constraint { + "unique or primary key constraint on columns \"PlaylistId\"" PK_Playlist +} + +"input type for inserting data into table \"Playlist\"" +input Playlist_insert_input { + Name: String + PlaylistTracks: PlaylistTrack_arr_rel_insert_input +} + +"aggregate max on columns" +type Playlist_max_fields { + Name: String + PlaylistId: Int +} + +"aggregate min on columns" +type Playlist_min_fields { + Name: String + PlaylistId: Int +} + +"response of any mutation on the table \"Playlist\"" +type Playlist_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Playlist!]! +} + +"input type for inserting object relation for remote table \"Playlist\"" +input Playlist_obj_rel_insert_input { + data: Playlist_insert_input! + "upsert condition" on_conflict: Playlist_on_conflict +} + +"on_conflict condition type for table \"Playlist\"" +input Playlist_on_conflict { + constraint: Playlist_constraint! + update_columns: [Playlist_update_column!]! = [] + where: Playlist_bool_exp +} + +"Ordering options when selecting data from \"Playlist\"." +input Playlist_order_by { + Name: order_by + PlaylistId: order_by + PlaylistTracks_aggregate: PlaylistTrack_aggregate_order_by +} + +"primary key columns input for table: Playlist" +input Playlist_pk_columns_input { + PlaylistId: Int! +} + +"select columns of table \"Playlist\"" +enum Playlist_select_column { + "column name" Name + "column name" PlaylistId +} + +"input type for updating data in table \"Playlist\"" +input Playlist_set_input { + Name: String +} + +"aggregate stddev on columns" +type Playlist_stddev_fields { + PlaylistId: Float +} + +"aggregate stddev_pop on columns" +type Playlist_stddev_pop_fields { + PlaylistId: Float +} + +"aggregate stddev_samp on columns" +type Playlist_stddev_samp_fields { + PlaylistId: Float +} + +"Streaming cursor of the table \"Playlist\"" +input Playlist_stream_cursor_input { + "Stream column input with initial value" initial_value: Playlist_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Playlist_stream_cursor_value_input { + Name: String + PlaylistId: Int +} + +"aggregate sum on columns" +type Playlist_sum_fields { + PlaylistId: Int +} + +"update columns of table \"Playlist\"" +enum Playlist_update_column { + "column name" Name +} + +input Playlist_updates { + "sets the columns of the filtered rows to the given values" _set: Playlist_set_input + "filter the rows which have to be updated" where: Playlist_bool_exp! +} + +"aggregate var_pop on columns" +type Playlist_var_pop_fields { + PlaylistId: Float +} + +"aggregate var_samp on columns" +type Playlist_var_samp_fields { + PlaylistId: Float +} + +"aggregate variance on columns" +type Playlist_variance_fields { + PlaylistId: Float +} + +scalar String + +"Boolean expression to compare columns of type \"String\". All fields are combined with logical 'AND'." +input String_comparison_exp { + _eq: String + _gt: String + _gte: String + "does the column match the given case-insensitive pattern" _ilike: String + _in: [String!] + "does the column match the given POSIX regular expression, case insensitive" _iregex: String + _is_null: Boolean + "does the column match the given pattern" _like: String + _lt: String + _lte: String + _neq: String + "does the column NOT match the given case-insensitive pattern" _nilike: String + _nin: [String!] + "does the column NOT match the given POSIX regular expression, case insensitive" _niregex: String + "does the column NOT match the given pattern" _nlike: String + "does the column NOT match the given POSIX regular expression, case sensitive" _nregex: String + "does the column NOT match the given SQL regular expression" _nsimilar: String + "does the column match the given POSIX regular expression, case sensitive" _regex: String + "does the column match the given SQL regular expression" _similar: String +} + +"columns and relationships of \"Track\"" +type Track { + "An object relationship" + Album: Album + AlbumId: Int + Bytes: Int + Composer: String + "An object relationship" + Genre: Genre + GenreId: Int + "An array relationship" + InvoiceLines("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "An aggregate relationship" + InvoiceLines_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "An object relationship" + MediaType: MediaType! + MediaTypeId: Int! + Milliseconds: Int! + Name: String! + "An array relationship" + PlaylistTracks("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "An aggregate relationship" + PlaylistTracks_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + TrackId: Int! + UnitPrice: numeric! +} + +"aggregated selection of \"Track\"" +type Track_aggregate { + aggregate: Track_aggregate_fields + nodes: [Track!]! +} + +input Track_aggregate_bool_exp { + count: Track_aggregate_bool_exp_count +} + +input Track_aggregate_bool_exp_count { + arguments: [Track_select_column!] + distinct: Boolean + filter: Track_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Track\"" +type Track_aggregate_fields { + avg: Track_avg_fields + count(columns: [Track_select_column!], distinct: Boolean): Int! + max: Track_max_fields + min: Track_min_fields + stddev: Track_stddev_fields + stddev_pop: Track_stddev_pop_fields + stddev_samp: Track_stddev_samp_fields + sum: Track_sum_fields + var_pop: Track_var_pop_fields + var_samp: Track_var_samp_fields + variance: Track_variance_fields +} + +"order by aggregate values of table \"Track\"" +input Track_aggregate_order_by { + avg: Track_avg_order_by + count: order_by + max: Track_max_order_by + min: Track_min_order_by + stddev: Track_stddev_order_by + stddev_pop: Track_stddev_pop_order_by + stddev_samp: Track_stddev_samp_order_by + sum: Track_sum_order_by + var_pop: Track_var_pop_order_by + var_samp: Track_var_samp_order_by + variance: Track_variance_order_by +} + +"input type for inserting array relation for remote table \"Track\"" +input Track_arr_rel_insert_input { + data: [Track_insert_input!]! + "upsert condition" on_conflict: Track_on_conflict +} + +"aggregate avg on columns" +type Track_avg_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by avg() on columns of table \"Track\"" +input Track_avg_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Boolean expression to filter rows from the table \"Track\". All fields are combined with a logical 'AND'." +input Track_bool_exp { + Album: Album_bool_exp + AlbumId: Int_comparison_exp + Bytes: Int_comparison_exp + Composer: String_comparison_exp + Genre: Genre_bool_exp + GenreId: Int_comparison_exp + InvoiceLines: InvoiceLine_bool_exp + InvoiceLines_aggregate: InvoiceLine_aggregate_bool_exp + MediaType: MediaType_bool_exp + MediaTypeId: Int_comparison_exp + Milliseconds: Int_comparison_exp + Name: String_comparison_exp + PlaylistTracks: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: PlaylistTrack_aggregate_bool_exp + TrackId: Int_comparison_exp + UnitPrice: numeric_comparison_exp + _and: [Track_bool_exp!] + _not: Track_bool_exp + _or: [Track_bool_exp!] +} + +"unique or primary key constraints on table \"Track\"" +enum Track_constraint { + "unique or primary key constraint on columns \"TrackId\"" PK_Track +} + +"input type for incrementing numeric columns in table \"Track\"" +input Track_inc_input { + AlbumId: Int + Bytes: Int + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + UnitPrice: numeric +} + +"input type for inserting data into table \"Track\"" +input Track_insert_input { + Album: Album_obj_rel_insert_input + AlbumId: Int + Bytes: Int + Composer: String + Genre: Genre_obj_rel_insert_input + GenreId: Int + InvoiceLines: InvoiceLine_arr_rel_insert_input + MediaType: MediaType_obj_rel_insert_input + MediaTypeId: Int + Milliseconds: Int + Name: String + PlaylistTracks: PlaylistTrack_arr_rel_insert_input + UnitPrice: numeric +} + +"aggregate max on columns" +type Track_max_fields { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"order by max() on columns of table \"Track\"" +input Track_max_order_by { + AlbumId: order_by + Bytes: order_by + Composer: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate min on columns" +type Track_min_fields { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"order by min() on columns of table \"Track\"" +input Track_min_order_by { + AlbumId: order_by + Bytes: order_by + Composer: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + TrackId: order_by + UnitPrice: order_by +} + +"response of any mutation on the table \"Track\"" +type Track_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Track!]! +} + +"input type for inserting object relation for remote table \"Track\"" +input Track_obj_rel_insert_input { + data: Track_insert_input! + "upsert condition" on_conflict: Track_on_conflict +} + +"on_conflict condition type for table \"Track\"" +input Track_on_conflict { + constraint: Track_constraint! + update_columns: [Track_update_column!]! = [] + where: Track_bool_exp +} + +"Ordering options when selecting data from \"Track\"." +input Track_order_by { + Album: Album_order_by + AlbumId: order_by + Bytes: order_by + Composer: order_by + Genre: Genre_order_by + GenreId: order_by + InvoiceLines_aggregate: InvoiceLine_aggregate_order_by + MediaType: MediaType_order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + PlaylistTracks_aggregate: PlaylistTrack_aggregate_order_by + TrackId: order_by + UnitPrice: order_by +} + +"primary key columns input for table: Track" +input Track_pk_columns_input { + TrackId: Int! +} + +"select columns of table \"Track\"" +enum Track_select_column { + "column name" AlbumId + "column name" Bytes + "column name" Composer + "column name" GenreId + "column name" MediaTypeId + "column name" Milliseconds + "column name" Name + "column name" TrackId + "column name" UnitPrice +} + +"input type for updating data in table \"Track\"" +input Track_set_input { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + UnitPrice: numeric +} + +"aggregate stddev on columns" +type Track_stddev_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev() on columns of table \"Track\"" +input Track_stddev_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_pop on columns" +type Track_stddev_pop_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_pop() on columns of table \"Track\"" +input Track_stddev_pop_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_samp on columns" +type Track_stddev_samp_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_samp() on columns of table \"Track\"" +input Track_stddev_samp_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Streaming cursor of the table \"Track\"" +input Track_stream_cursor_input { + "Stream column input with initial value" initial_value: Track_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Track_stream_cursor_value_input { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"aggregate sum on columns" +type Track_sum_fields { + AlbumId: Int + Bytes: Int + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + TrackId: Int + UnitPrice: numeric +} + +"order by sum() on columns of table \"Track\"" +input Track_sum_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"update columns of table \"Track\"" +enum Track_update_column { + "column name" AlbumId + "column name" Bytes + "column name" Composer + "column name" GenreId + "column name" MediaTypeId + "column name" Milliseconds + "column name" Name + "column name" UnitPrice +} + +input Track_updates { + "increments the numeric columns with given value of the filtered values" _inc: Track_inc_input + "sets the columns of the filtered rows to the given values" _set: Track_set_input + "filter the rows which have to be updated" where: Track_bool_exp! +} + +"aggregate var_pop on columns" +type Track_var_pop_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_pop() on columns of table \"Track\"" +input Track_var_pop_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate var_samp on columns" +type Track_var_samp_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_samp() on columns of table \"Track\"" +input Track_var_samp_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate variance on columns" +type Track_variance_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by variance() on columns of table \"Track\"" +input Track_variance_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"ordering argument of a cursor" +enum cursor_ordering { + "ascending ordering of the cursor" ASC + "descending ordering of the cursor" DESC +} + +"mutation root" +type mutation_root { + "delete data from the table: \"Album\"" + delete_Album("filter the rows which have to be deleted" where: Album_bool_exp!): Album_mutation_response + "delete single row from the table: \"Album\"" + delete_Album_by_pk(AlbumId: Int!): Album + "delete data from the table: \"Artist\"" + delete_Artist("filter the rows which have to be deleted" where: Artist_bool_exp!): Artist_mutation_response + "delete single row from the table: \"Artist\"" + delete_Artist_by_pk(ArtistId: Int!): Artist + "delete data from the table: \"Customer\"" + delete_Customer("filter the rows which have to be deleted" where: Customer_bool_exp!): Customer_mutation_response + "delete single row from the table: \"Customer\"" + delete_Customer_by_pk(CustomerId: Int!): Customer + "delete data from the table: \"Employee\"" + delete_Employee("filter the rows which have to be deleted" where: Employee_bool_exp!): Employee_mutation_response + "delete single row from the table: \"Employee\"" + delete_Employee_by_pk(EmployeeId: Int!): Employee + "delete data from the table: \"Genre\"" + delete_Genre("filter the rows which have to be deleted" where: Genre_bool_exp!): Genre_mutation_response + "delete single row from the table: \"Genre\"" + delete_Genre_by_pk(GenreId: Int!): Genre + "delete data from the table: \"Invoice\"" + delete_Invoice("filter the rows which have to be deleted" where: Invoice_bool_exp!): Invoice_mutation_response + "delete data from the table: \"InvoiceLine\"" + delete_InvoiceLine("filter the rows which have to be deleted" where: InvoiceLine_bool_exp!): InvoiceLine_mutation_response + "delete single row from the table: \"InvoiceLine\"" + delete_InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "delete single row from the table: \"Invoice\"" + delete_Invoice_by_pk(InvoiceId: Int!): Invoice + "delete data from the table: \"MediaType\"" + delete_MediaType("filter the rows which have to be deleted" where: MediaType_bool_exp!): MediaType_mutation_response + "delete single row from the table: \"MediaType\"" + delete_MediaType_by_pk(MediaTypeId: Int!): MediaType + "delete data from the table: \"Playlist\"" + delete_Playlist("filter the rows which have to be deleted" where: Playlist_bool_exp!): Playlist_mutation_response + "delete data from the table: \"PlaylistTrack\"" + delete_PlaylistTrack("filter the rows which have to be deleted" where: PlaylistTrack_bool_exp!): PlaylistTrack_mutation_response + "delete single row from the table: \"PlaylistTrack\"" + delete_PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "delete single row from the table: \"Playlist\"" + delete_Playlist_by_pk(PlaylistId: Int!): Playlist + "delete data from the table: \"Track\"" + delete_Track("filter the rows which have to be deleted" where: Track_bool_exp!): Track_mutation_response + "delete single row from the table: \"Track\"" + delete_Track_by_pk(TrackId: Int!): Track + "insert data into the table: \"Album\"" + insert_Album("the rows to be inserted" objects: [Album_insert_input!]!, "upsert condition" on_conflict: Album_on_conflict): Album_mutation_response + "insert a single row into the table: \"Album\"" + insert_Album_one("the row to be inserted" object: Album_insert_input!, "upsert condition" on_conflict: Album_on_conflict): Album + "insert data into the table: \"Artist\"" + insert_Artist("the rows to be inserted" objects: [Artist_insert_input!]!, "upsert condition" on_conflict: Artist_on_conflict): Artist_mutation_response + "insert a single row into the table: \"Artist\"" + insert_Artist_one("the row to be inserted" object: Artist_insert_input!, "upsert condition" on_conflict: Artist_on_conflict): Artist + "insert data into the table: \"Customer\"" + insert_Customer("the rows to be inserted" objects: [Customer_insert_input!]!, "upsert condition" on_conflict: Customer_on_conflict): Customer_mutation_response + "insert a single row into the table: \"Customer\"" + insert_Customer_one("the row to be inserted" object: Customer_insert_input!, "upsert condition" on_conflict: Customer_on_conflict): Customer + "insert data into the table: \"Employee\"" + insert_Employee("the rows to be inserted" objects: [Employee_insert_input!]!, "upsert condition" on_conflict: Employee_on_conflict): Employee_mutation_response + "insert a single row into the table: \"Employee\"" + insert_Employee_one("the row to be inserted" object: Employee_insert_input!, "upsert condition" on_conflict: Employee_on_conflict): Employee + "insert data into the table: \"Genre\"" + insert_Genre("the rows to be inserted" objects: [Genre_insert_input!]!, "upsert condition" on_conflict: Genre_on_conflict): Genre_mutation_response + "insert a single row into the table: \"Genre\"" + insert_Genre_one("the row to be inserted" object: Genre_insert_input!, "upsert condition" on_conflict: Genre_on_conflict): Genre + "insert data into the table: \"Invoice\"" + insert_Invoice("the rows to be inserted" objects: [Invoice_insert_input!]!, "upsert condition" on_conflict: Invoice_on_conflict): Invoice_mutation_response + "insert data into the table: \"InvoiceLine\"" + insert_InvoiceLine("the rows to be inserted" objects: [InvoiceLine_insert_input!]!, "upsert condition" on_conflict: InvoiceLine_on_conflict): InvoiceLine_mutation_response + "insert a single row into the table: \"InvoiceLine\"" + insert_InvoiceLine_one("the row to be inserted" object: InvoiceLine_insert_input!, "upsert condition" on_conflict: InvoiceLine_on_conflict): InvoiceLine + "insert a single row into the table: \"Invoice\"" + insert_Invoice_one("the row to be inserted" object: Invoice_insert_input!, "upsert condition" on_conflict: Invoice_on_conflict): Invoice + "insert data into the table: \"MediaType\"" + insert_MediaType("the rows to be inserted" objects: [MediaType_insert_input!]!, "upsert condition" on_conflict: MediaType_on_conflict): MediaType_mutation_response + "insert a single row into the table: \"MediaType\"" + insert_MediaType_one("the row to be inserted" object: MediaType_insert_input!, "upsert condition" on_conflict: MediaType_on_conflict): MediaType + "insert data into the table: \"Playlist\"" + insert_Playlist("the rows to be inserted" objects: [Playlist_insert_input!]!, "upsert condition" on_conflict: Playlist_on_conflict): Playlist_mutation_response + "insert data into the table: \"PlaylistTrack\"" + insert_PlaylistTrack("the rows to be inserted" objects: [PlaylistTrack_insert_input!]!, "upsert condition" on_conflict: PlaylistTrack_on_conflict): PlaylistTrack_mutation_response + "insert a single row into the table: \"PlaylistTrack\"" + insert_PlaylistTrack_one("the row to be inserted" object: PlaylistTrack_insert_input!, "upsert condition" on_conflict: PlaylistTrack_on_conflict): PlaylistTrack + "insert a single row into the table: \"Playlist\"" + insert_Playlist_one("the row to be inserted" object: Playlist_insert_input!, "upsert condition" on_conflict: Playlist_on_conflict): Playlist + "insert data into the table: \"Track\"" + insert_Track("the rows to be inserted" objects: [Track_insert_input!]!, "upsert condition" on_conflict: Track_on_conflict): Track_mutation_response + "insert a single row into the table: \"Track\"" + insert_Track_one("the row to be inserted" object: Track_insert_input!, "upsert condition" on_conflict: Track_on_conflict): Track + "update data of the table: \"Album\"" + update_Album("increments the numeric columns with given value of the filtered values" _inc: Album_inc_input, "sets the columns of the filtered rows to the given values" _set: Album_set_input, "filter the rows which have to be updated" where: Album_bool_exp!): Album_mutation_response + "update single row of the table: \"Album\"" + update_Album_by_pk("increments the numeric columns with given value of the filtered values" _inc: Album_inc_input, "sets the columns of the filtered rows to the given values" _set: Album_set_input, pk_columns: Album_pk_columns_input!): Album + "update multiples rows of table: \"Album\"" + update_Album_many("updates to execute, in order" updates: [Album_updates!]!): [Album_mutation_response] + "update data of the table: \"Artist\"" + update_Artist("sets the columns of the filtered rows to the given values" _set: Artist_set_input, "filter the rows which have to be updated" where: Artist_bool_exp!): Artist_mutation_response + "update single row of the table: \"Artist\"" + update_Artist_by_pk("sets the columns of the filtered rows to the given values" _set: Artist_set_input, pk_columns: Artist_pk_columns_input!): Artist + "update multiples rows of table: \"Artist\"" + update_Artist_many("updates to execute, in order" updates: [Artist_updates!]!): [Artist_mutation_response] + "update data of the table: \"Customer\"" + update_Customer("increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input, "sets the columns of the filtered rows to the given values" _set: Customer_set_input, "filter the rows which have to be updated" where: Customer_bool_exp!): Customer_mutation_response + "update single row of the table: \"Customer\"" + update_Customer_by_pk("increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input, "sets the columns of the filtered rows to the given values" _set: Customer_set_input, pk_columns: Customer_pk_columns_input!): Customer + "update multiples rows of table: \"Customer\"" + update_Customer_many("updates to execute, in order" updates: [Customer_updates!]!): [Customer_mutation_response] + "update data of the table: \"Employee\"" + update_Employee("increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input, "sets the columns of the filtered rows to the given values" _set: Employee_set_input, "filter the rows which have to be updated" where: Employee_bool_exp!): Employee_mutation_response + "update single row of the table: \"Employee\"" + update_Employee_by_pk("increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input, "sets the columns of the filtered rows to the given values" _set: Employee_set_input, pk_columns: Employee_pk_columns_input!): Employee + "update multiples rows of table: \"Employee\"" + update_Employee_many("updates to execute, in order" updates: [Employee_updates!]!): [Employee_mutation_response] + "update data of the table: \"Genre\"" + update_Genre("sets the columns of the filtered rows to the given values" _set: Genre_set_input, "filter the rows which have to be updated" where: Genre_bool_exp!): Genre_mutation_response + "update single row of the table: \"Genre\"" + update_Genre_by_pk("sets the columns of the filtered rows to the given values" _set: Genre_set_input, pk_columns: Genre_pk_columns_input!): Genre + "update multiples rows of table: \"Genre\"" + update_Genre_many("updates to execute, in order" updates: [Genre_updates!]!): [Genre_mutation_response] + "update data of the table: \"Invoice\"" + update_Invoice("increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input, "sets the columns of the filtered rows to the given values" _set: Invoice_set_input, "filter the rows which have to be updated" where: Invoice_bool_exp!): Invoice_mutation_response + "update data of the table: \"InvoiceLine\"" + update_InvoiceLine("increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input, "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input, "filter the rows which have to be updated" where: InvoiceLine_bool_exp!): InvoiceLine_mutation_response + "update single row of the table: \"InvoiceLine\"" + update_InvoiceLine_by_pk("increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input, "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input, pk_columns: InvoiceLine_pk_columns_input!): InvoiceLine + "update multiples rows of table: \"InvoiceLine\"" + update_InvoiceLine_many("updates to execute, in order" updates: [InvoiceLine_updates!]!): [InvoiceLine_mutation_response] + "update single row of the table: \"Invoice\"" + update_Invoice_by_pk("increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input, "sets the columns of the filtered rows to the given values" _set: Invoice_set_input, pk_columns: Invoice_pk_columns_input!): Invoice + "update multiples rows of table: \"Invoice\"" + update_Invoice_many("updates to execute, in order" updates: [Invoice_updates!]!): [Invoice_mutation_response] + "update data of the table: \"MediaType\"" + update_MediaType("sets the columns of the filtered rows to the given values" _set: MediaType_set_input, "filter the rows which have to be updated" where: MediaType_bool_exp!): MediaType_mutation_response + "update single row of the table: \"MediaType\"" + update_MediaType_by_pk("sets the columns of the filtered rows to the given values" _set: MediaType_set_input, pk_columns: MediaType_pk_columns_input!): MediaType + "update multiples rows of table: \"MediaType\"" + update_MediaType_many("updates to execute, in order" updates: [MediaType_updates!]!): [MediaType_mutation_response] + "update data of the table: \"Playlist\"" + update_Playlist("sets the columns of the filtered rows to the given values" _set: Playlist_set_input, "filter the rows which have to be updated" where: Playlist_bool_exp!): Playlist_mutation_response + "update data of the table: \"PlaylistTrack\"" + update_PlaylistTrack("increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input, "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input, "filter the rows which have to be updated" where: PlaylistTrack_bool_exp!): PlaylistTrack_mutation_response + "update single row of the table: \"PlaylistTrack\"" + update_PlaylistTrack_by_pk("increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input, "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input, pk_columns: PlaylistTrack_pk_columns_input!): PlaylistTrack + "update multiples rows of table: \"PlaylistTrack\"" + update_PlaylistTrack_many("updates to execute, in order" updates: [PlaylistTrack_updates!]!): [PlaylistTrack_mutation_response] + "update single row of the table: \"Playlist\"" + update_Playlist_by_pk("sets the columns of the filtered rows to the given values" _set: Playlist_set_input, pk_columns: Playlist_pk_columns_input!): Playlist + "update multiples rows of table: \"Playlist\"" + update_Playlist_many("updates to execute, in order" updates: [Playlist_updates!]!): [Playlist_mutation_response] + "update data of the table: \"Track\"" + update_Track("increments the numeric columns with given value of the filtered values" _inc: Track_inc_input, "sets the columns of the filtered rows to the given values" _set: Track_set_input, "filter the rows which have to be updated" where: Track_bool_exp!): Track_mutation_response + "update single row of the table: \"Track\"" + update_Track_by_pk("increments the numeric columns with given value of the filtered values" _inc: Track_inc_input, "sets the columns of the filtered rows to the given values" _set: Track_set_input, pk_columns: Track_pk_columns_input!): Track + "update multiples rows of table: \"Track\"" + update_Track_many("updates to execute, in order" updates: [Track_updates!]!): [Track_mutation_response] +} + +scalar numeric + +"Boolean expression to compare columns of type \"numeric\". All fields are combined with logical 'AND'." +input numeric_comparison_exp { + _eq: numeric + _gt: numeric + _gte: numeric + _in: [numeric!] + _is_null: Boolean + _lt: numeric + _lte: numeric + _neq: numeric + _nin: [numeric!] +} + +"column ordering options" +enum order_by { + "in ascending order, nulls last" asc + "in ascending order, nulls first" asc_nulls_first + "in ascending order, nulls last" asc_nulls_last + "in descending order, nulls first" desc + "in descending order, nulls first" desc_nulls_first + "in descending order, nulls last" desc_nulls_last +} + +type query_root { + "fetch data from the table: \"Album\"" + Album("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch aggregated fields from the table: \"Album\"" + Album_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + "fetch data from the table: \"Album\" using primary key columns" + Album_by_pk(AlbumId: Int!): Album + "fetch data from the table: \"Artist\"" + Artist("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch aggregated fields from the table: \"Artist\"" + Artist_aggregate("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): Artist_aggregate! + "fetch data from the table: \"Artist\" using primary key columns" + Artist_by_pk(ArtistId: Int!): Artist + "fetch data from the table: \"Customer\"" + Customer("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch aggregated fields from the table: \"Customer\"" + Customer_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + "fetch data from the table: \"Customer\" using primary key columns" + Customer_by_pk(CustomerId: Int!): Customer + "fetch data from the table: \"Employee\"" + Employee("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch aggregated fields from the table: \"Employee\"" + Employee_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + "fetch data from the table: \"Employee\" using primary key columns" + Employee_by_pk(EmployeeId: Int!): Employee + "fetch data from the table: \"Genre\"" + Genre("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch aggregated fields from the table: \"Genre\"" + Genre_aggregate("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): Genre_aggregate! + "fetch data from the table: \"Genre\" using primary key columns" + Genre_by_pk(GenreId: Int!): Genre + "fetch data from the table: \"Invoice\"" + Invoice("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"InvoiceLine\"" + InvoiceLine("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"InvoiceLine\"" + InvoiceLine_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "fetch data from the table: \"InvoiceLine\" using primary key columns" + InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "fetch aggregated fields from the table: \"Invoice\"" + Invoice_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + "fetch data from the table: \"Invoice\" using primary key columns" + Invoice_by_pk(InvoiceId: Int!): Invoice + "fetch data from the table: \"MediaType\"" + MediaType("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch aggregated fields from the table: \"MediaType\"" + MediaType_aggregate("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): MediaType_aggregate! + "fetch data from the table: \"MediaType\" using primary key columns" + MediaType_by_pk(MediaTypeId: Int!): MediaType + "fetch data from the table: \"Playlist\"" + Playlist("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"PlaylistTrack\"" + PlaylistTrack("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"PlaylistTrack\"" + PlaylistTrack_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + "fetch data from the table: \"PlaylistTrack\" using primary key columns" + PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "fetch aggregated fields from the table: \"Playlist\"" + Playlist_aggregate("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): Playlist_aggregate! + "fetch data from the table: \"Playlist\" using primary key columns" + Playlist_by_pk(PlaylistId: Int!): Playlist + "fetch data from the table: \"Track\"" + Track("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "fetch aggregated fields from the table: \"Track\"" + Track_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! + "fetch data from the table: \"Track\" using primary key columns" + Track_by_pk(TrackId: Int!): Track +} + +type subscription_root { + "fetch data from the table: \"Album\"" + Album("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch aggregated fields from the table: \"Album\"" + Album_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + "fetch data from the table: \"Album\" using primary key columns" + Album_by_pk(AlbumId: Int!): Album + "fetch data from the table in a streaming manner: \"Album\"" + Album_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Album_stream_cursor_input]!, "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch data from the table: \"Artist\"" + Artist("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch aggregated fields from the table: \"Artist\"" + Artist_aggregate("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): Artist_aggregate! + "fetch data from the table: \"Artist\" using primary key columns" + Artist_by_pk(ArtistId: Int!): Artist + "fetch data from the table in a streaming manner: \"Artist\"" + Artist_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Artist_stream_cursor_input]!, "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch data from the table: \"Customer\"" + Customer("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch aggregated fields from the table: \"Customer\"" + Customer_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + "fetch data from the table: \"Customer\" using primary key columns" + Customer_by_pk(CustomerId: Int!): Customer + "fetch data from the table in a streaming manner: \"Customer\"" + Customer_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Customer_stream_cursor_input]!, "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch data from the table: \"Employee\"" + Employee("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch aggregated fields from the table: \"Employee\"" + Employee_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + "fetch data from the table: \"Employee\" using primary key columns" + Employee_by_pk(EmployeeId: Int!): Employee + "fetch data from the table in a streaming manner: \"Employee\"" + Employee_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Employee_stream_cursor_input]!, "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch data from the table: \"Genre\"" + Genre("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch aggregated fields from the table: \"Genre\"" + Genre_aggregate("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): Genre_aggregate! + "fetch data from the table: \"Genre\" using primary key columns" + Genre_by_pk(GenreId: Int!): Genre + "fetch data from the table in a streaming manner: \"Genre\"" + Genre_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Genre_stream_cursor_input]!, "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch data from the table: \"Invoice\"" + Invoice("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"InvoiceLine\"" + InvoiceLine("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"InvoiceLine\"" + InvoiceLine_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "fetch data from the table: \"InvoiceLine\" using primary key columns" + InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "fetch data from the table in a streaming manner: \"InvoiceLine\"" + InvoiceLine_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [InvoiceLine_stream_cursor_input]!, "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"Invoice\"" + Invoice_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + "fetch data from the table: \"Invoice\" using primary key columns" + Invoice_by_pk(InvoiceId: Int!): Invoice + "fetch data from the table in a streaming manner: \"Invoice\"" + Invoice_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Invoice_stream_cursor_input]!, "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"MediaType\"" + MediaType("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch aggregated fields from the table: \"MediaType\"" + MediaType_aggregate("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): MediaType_aggregate! + "fetch data from the table: \"MediaType\" using primary key columns" + MediaType_by_pk(MediaTypeId: Int!): MediaType + "fetch data from the table in a streaming manner: \"MediaType\"" + MediaType_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [MediaType_stream_cursor_input]!, "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch data from the table: \"Playlist\"" + Playlist("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"PlaylistTrack\"" + PlaylistTrack("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"PlaylistTrack\"" + PlaylistTrack_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + "fetch data from the table: \"PlaylistTrack\" using primary key columns" + PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "fetch data from the table in a streaming manner: \"PlaylistTrack\"" + PlaylistTrack_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [PlaylistTrack_stream_cursor_input]!, "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"Playlist\"" + Playlist_aggregate("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): Playlist_aggregate! + "fetch data from the table: \"Playlist\" using primary key columns" + Playlist_by_pk(PlaylistId: Int!): Playlist + "fetch data from the table in a streaming manner: \"Playlist\"" + Playlist_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Playlist_stream_cursor_input]!, "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"Track\"" + Track("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "fetch aggregated fields from the table: \"Track\"" + Track_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! + "fetch data from the table: \"Track\" using primary key columns" + Track_by_pk(TrackId: Int!): Track + "fetch data from the table in a streaming manner: \"Track\"" + Track_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Track_stream_cursor_input]!, "filter the rows returned" where: Track_bool_exp): [Track!]! +} + +scalar timestamp + +"Boolean expression to compare columns of type \"timestamp\". All fields are combined with logical 'AND'." +input timestamp_comparison_exp { + _eq: timestamp + _gt: timestamp + _gte: timestamp + _in: [timestamp!] + _is_null: Boolean + _lt: timestamp + _lte: timestamp + _neq: timestamp + _nin: [timestamp!] +} diff --git a/crates/ndc-graphql/tests/config-2/mutations/01_single_operation.request.json b/crates/ndc-graphql/tests/config-2/mutations/01_single_operation.request.json new file mode 100644 index 0000000..569d506 --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/mutations/01_single_operation.request.json @@ -0,0 +1,36 @@ +{ + "$schema": "_mutation_request.schema.json", + "operations": [ + { + "type": "procedure", + "name": "update_Album_by_pk", + "arguments": { + "_set": { + "ArtistId": 1 + }, + "pk_columns": { + "AlbumId": 1 + }, + "_headers": { + "Authorization": "Bearer " + } + }, + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + } + } + } + } + ], + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/mutations/02_multiple_operations.request.json b/crates/ndc-graphql/tests/config-2/mutations/02_multiple_operations.request.json new file mode 100644 index 0000000..c5aaeef --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/mutations/02_multiple_operations.request.json @@ -0,0 +1,62 @@ +{ + "operations": [ + { + "type": "procedure", + "name": "update_Album_by_pk", + "arguments": { + "_set": { + "ArtistId": 1 + }, + "pk_columns": { + "AlbumId": 1 + }, + "_headers": { + "Authorization": "Bearer " + } + }, + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + } + } + } + }, + { + "type": "procedure", + "name": "update_Album_by_pk", + "arguments": { + "_set": { + "ArtistId": 1 + }, + "pk_columns": { + "AlbumId": 1 + } + }, + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + } + } + } + } + ], + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/mutations/_mutation_request.schema.json b/crates/ndc-graphql/tests/config-2/mutations/_mutation_request.schema.json new file mode 100644 index 0000000..4ccdb61 --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/mutations/_mutation_request.schema.json @@ -0,0 +1,989 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Mutation Request", + "type": "object", + "required": [ + "collection_relationships", + "operations" + ], + "properties": { + "operations": { + "description": "The mutation operations to perform", + "type": "array", + "items": { + "$ref": "#/definitions/MutationOperation" + } + }, + "collection_relationships": { + "description": "The relationships between collections involved in the entire mutation request", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Relationship" + } + } + }, + "definitions": { + "MutationOperation": { + "title": "Mutation Operation", + "oneOf": [ + { + "type": "object", + "required": [ + "arguments", + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "procedure" + ] + }, + "name": { + "description": "The name of a procedure", + "type": "string" + }, + "arguments": { + "description": "Any named procedure arguments", + "type": "object", + "additionalProperties": true + }, + "fields": { + "description": "The fields to return from the result, or null to return everything", + "anyOf": [ + { + "$ref": "#/definitions/NestedField" + }, + { + "type": "null" + } + ] + } + } + } + ] + }, + "NestedField": { + "title": "NestedField", + "oneOf": [ + { + "title": "NestedObject", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "object" + ] + }, + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Field" + } + } + } + }, + { + "title": "NestedArray", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "array" + ] + }, + "fields": { + "$ref": "#/definitions/NestedField" + } + } + } + ] + }, + "Field": { + "title": "Field", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "type": "string" + }, + "fields": { + "description": "When the type of the column is a (possibly-nullable) array or object, the caller can request a subset of the complete column data, by specifying fields to fetch here. If omitted, the column data will be fetched in full.", + "anyOf": [ + { + "$ref": "#/definitions/NestedField" + }, + { + "type": "null" + } + ] + }, + "arguments": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Argument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "query", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "relationship" + ] + }, + "query": { + "$ref": "#/definitions/Query" + }, + "relationship": { + "description": "The name of the relationship to follow for the subquery", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "Argument": { + "title": "Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + } + ] + }, + "Query": { + "title": "Query", + "type": "object", + "properties": { + "aggregates": { + "description": "Aggregate fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Aggregate" + } + }, + "fields": { + "description": "Fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Field" + } + }, + "limit": { + "description": "Optionally limit to N results", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "offset": { + "description": "Optionally offset from the Nth result", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "order_by": { + "anyOf": [ + { + "$ref": "#/definitions/OrderBy" + }, + { + "type": "null" + } + ] + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "Aggregate": { + "title": "Aggregate", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "distinct", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column_count" + ] + }, + "column": { + "description": "The column to apply the count aggregate function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "distinct": { + "description": "Whether or not only distinct items should be counted", + "type": "boolean" + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count" + ] + } + } + } + ] + }, + "OrderBy": { + "title": "Order By", + "type": "object", + "required": [ + "elements" + ], + "properties": { + "elements": { + "description": "The elements to order by, in priority order", + "type": "array", + "items": { + "$ref": "#/definitions/OrderByElement" + } + } + } + }, + "OrderByElement": { + "title": "Order By Element", + "type": "object", + "required": [ + "order_direction", + "target" + ], + "properties": { + "order_direction": { + "$ref": "#/definitions/OrderDirection" + }, + "target": { + "$ref": "#/definitions/OrderByTarget" + } + } + }, + "OrderDirection": { + "title": "Order Direction", + "type": "string", + "enum": [ + "asc", + "desc" + ] + }, + "OrderByTarget": { + "title": "Order By Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column_aggregate" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count_aggregate" + ] + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + } + ] + }, + "PathElement": { + "title": "Path Element", + "type": "object", + "required": [ + "arguments", + "relationship" + ], + "properties": { + "relationship": { + "description": "The name of the relationship to follow", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + }, + "predicate": { + "description": "A predicate expression to apply to the target collection", + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "RelationshipArgument": { + "title": "Relationship Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "Expression": { + "title": "Expression", + "oneOf": [ + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "and" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "or" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expression", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "not" + ] + }, + "expression": { + "$ref": "#/definitions/Expression" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "$ref": "#/definitions/UnaryComparisonOperator" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "binary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/ComparisonValue" + } + } + }, + { + "type": "object", + "required": [ + "in_collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "exists" + ] + }, + "in_collection": { + "$ref": "#/definitions/ExistsInCollection" + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + } + ] + }, + "ComparisonTarget": { + "title": "Comparison Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "root_collection_column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + ] + }, + "UnaryComparisonOperator": { + "title": "Unary Comparison Operator", + "type": "string", + "enum": [ + "is_null" + ] + }, + "ComparisonValue": { + "title": "Comparison Value", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + } + } + }, + { + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "scalar" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "ExistsInCollection": { + "title": "Exists In Collection", + "oneOf": [ + { + "type": "object", + "required": [ + "arguments", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "related" + ] + }, + "relationship": { + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unrelated" + ] + }, + "collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "Relationship": { + "title": "Relationship", + "type": "object", + "required": [ + "arguments", + "column_mapping", + "relationship_type", + "target_collection" + ], + "properties": { + "column_mapping": { + "description": "A mapping between columns on the source collection to columns on the target collection", + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "relationship_type": { + "$ref": "#/definitions/RelationshipType" + }, + "target_collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + "RelationshipType": { + "title": "Relationship Type", + "type": "string", + "enum": [ + "object", + "array" + ] + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/queries/01_basic_query.request.json b/crates/ndc-graphql/tests/config-2/queries/01_basic_query.request.json new file mode 100644 index 0000000..06ed356 --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/queries/01_basic_query.request.json @@ -0,0 +1,104 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album", + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + }, + "MediaType": { + "type": "column", + "column": "MediaType", + "fields": { + "type": "object", + "fields": { + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "MediaTypeId": { + "type": "column", + "column": "MediaTypeId", + "fields": null + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "arguments": { + "_headers": { + "type": "literal", + "value": { + "Authorization": "Bearer " + } + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/queries/02_root_node_parameters.request.json b/crates/ndc-graphql/tests/config-2/queries/02_root_node_parameters.request.json new file mode 100644 index 0000000..30ccaf2 --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/queries/02_root_node_parameters.request.json @@ -0,0 +1,116 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album", + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + }, + "MediaType": { + "type": "column", + "column": "MediaType", + "fields": { + "type": "object", + "fields": { + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "MediaTypeId": { + "type": "column", + "column": "MediaTypeId", + "fields": null + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "arguments": { + "limit": { + "type": "literal", + "value": 20 + }, + "where": { + "type": "literal", + "value": { + "AlbumId": { + "_gt": 5 + } + } + }, + "_headers": { + "type": "literal", + "value": { + "Authorization": "Bearer " + } + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/queries/03_child_node_parameters.request.json b/crates/ndc-graphql/tests/config-2/queries/03_child_node_parameters.request.json new file mode 100644 index 0000000..953c96a --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/queries/03_child_node_parameters.request.json @@ -0,0 +1,122 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album", + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + }, + "MediaType": { + "type": "column", + "column": "MediaType", + "fields": { + "type": "object", + "fields": { + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "MediaTypeId": { + "type": "column", + "column": "MediaTypeId", + "fields": null + } + } + } + } + } + } + }, + "arguments": { + "limit": { + "type": "literal", + "value": 5 + } + } + } + } + } + } + } + } + }, + "arguments": { + "limit": { + "type": "literal", + "value": 20 + }, + "where": { + "type": "literal", + "value": { + "AlbumId": { + "_gt": 5 + } + } + }, + "_headers": { + "type": "literal", + "value": { + "Authorization": "Bearer " + } + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/queries/04_foreach.request.json b/crates/ndc-graphql/tests/config-2/queries/04_foreach.request.json new file mode 100644 index 0000000..cf44088 --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/queries/04_foreach.request.json @@ -0,0 +1,125 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album_by_pk", + "variables": [ + { + "AlbumId": 1, + "TracksWhere": { + "TrackId": { + "_gte": 1 + } + }, + "headers": { + "Authorization": "Bearer " + } + }, + { + "AlbumId": 2, + "TracksWhere": { + "TrackId": { + "_gte": 2 + } + }, + "headers": { + "Authorization": "Bearer " + } + }, + { + "AlbumId": 3, + "TracksWhere": { + "TrackId": { + "_gte": 3 + } + }, + "headers": { + "Authorization": "Bearer " + } + } + ], + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + } + } + } + }, + "arguments": { + "where": { + "type": "variable", + "name": "TracksWhere" + } + } + } + } + } + } + } + }, + "arguments": { + "AlbumId": { + "type": "variable", + "name": "AlbumId" + }, + "_headers": { + "type": "variable", + "name": "headers" + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-2/queries/_query_request.schema.json b/crates/ndc-graphql/tests/config-2/queries/_query_request.schema.json new file mode 100644 index 0000000..6f13801 --- /dev/null +++ b/crates/ndc-graphql/tests/config-2/queries/_query_request.schema.json @@ -0,0 +1,974 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Query Request", + "description": "This is the request body of the query POST endpoint", + "type": "object", + "required": [ + "arguments", + "collection", + "collection_relationships", + "query" + ], + "properties": { + "collection": { + "description": "The name of a collection", + "type": "string" + }, + "query": { + "description": "The query syntax tree", + "allOf": [ + { + "$ref": "#/definitions/Query" + } + ] + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Argument" + } + }, + "collection_relationships": { + "description": "Any relationships between collections involved in the query request", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Relationship" + } + }, + "variables": { + "description": "One set of named variables for each rowset to fetch. Each variable set should be subtituted in turn, and a fresh set of rows returned.", + "type": [ + "array", + "null" + ], + "items": { + "type": "object", + "additionalProperties": true + } + } + }, + "definitions": { + "Query": { + "title": "Query", + "type": "object", + "properties": { + "aggregates": { + "description": "Aggregate fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Aggregate" + } + }, + "fields": { + "description": "Fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Field" + } + }, + "limit": { + "description": "Optionally limit to N results", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "offset": { + "description": "Optionally offset from the Nth result", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "order_by": { + "anyOf": [ + { + "$ref": "#/definitions/OrderBy" + }, + { + "type": "null" + } + ] + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "Aggregate": { + "title": "Aggregate", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "distinct", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column_count" + ] + }, + "column": { + "description": "The column to apply the count aggregate function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "distinct": { + "description": "Whether or not only distinct items should be counted", + "type": "boolean" + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count" + ] + } + } + } + ] + }, + "Field": { + "title": "Field", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "type": "string" + }, + "fields": { + "description": "When the type of the column is a (possibly-nullable) array or object, the caller can request a subset of the complete column data, by specifying fields to fetch here. If omitted, the column data will be fetched in full.", + "anyOf": [ + { + "$ref": "#/definitions/NestedField" + }, + { + "type": "null" + } + ] + }, + "arguments": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Argument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "query", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "relationship" + ] + }, + "query": { + "$ref": "#/definitions/Query" + }, + "relationship": { + "description": "The name of the relationship to follow for the subquery", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "NestedField": { + "title": "NestedField", + "oneOf": [ + { + "title": "NestedObject", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "object" + ] + }, + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Field" + } + } + } + }, + { + "title": "NestedArray", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "array" + ] + }, + "fields": { + "$ref": "#/definitions/NestedField" + } + } + } + ] + }, + "Argument": { + "title": "Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + } + ] + }, + "RelationshipArgument": { + "title": "Relationship Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "OrderBy": { + "title": "Order By", + "type": "object", + "required": [ + "elements" + ], + "properties": { + "elements": { + "description": "The elements to order by, in priority order", + "type": "array", + "items": { + "$ref": "#/definitions/OrderByElement" + } + } + } + }, + "OrderByElement": { + "title": "Order By Element", + "type": "object", + "required": [ + "order_direction", + "target" + ], + "properties": { + "order_direction": { + "$ref": "#/definitions/OrderDirection" + }, + "target": { + "$ref": "#/definitions/OrderByTarget" + } + } + }, + "OrderDirection": { + "title": "Order Direction", + "type": "string", + "enum": [ + "asc", + "desc" + ] + }, + "OrderByTarget": { + "title": "Order By Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column_aggregate" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count_aggregate" + ] + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + } + ] + }, + "PathElement": { + "title": "Path Element", + "type": "object", + "required": [ + "arguments", + "relationship" + ], + "properties": { + "relationship": { + "description": "The name of the relationship to follow", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + }, + "predicate": { + "description": "A predicate expression to apply to the target collection", + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "Expression": { + "title": "Expression", + "oneOf": [ + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "and" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "or" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expression", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "not" + ] + }, + "expression": { + "$ref": "#/definitions/Expression" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "$ref": "#/definitions/UnaryComparisonOperator" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "binary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/ComparisonValue" + } + } + }, + { + "type": "object", + "required": [ + "in_collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "exists" + ] + }, + "in_collection": { + "$ref": "#/definitions/ExistsInCollection" + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + } + ] + }, + "ComparisonTarget": { + "title": "Comparison Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "root_collection_column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + ] + }, + "UnaryComparisonOperator": { + "title": "Unary Comparison Operator", + "type": "string", + "enum": [ + "is_null" + ] + }, + "ComparisonValue": { + "title": "Comparison Value", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + } + } + }, + { + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "scalar" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "ExistsInCollection": { + "title": "Exists In Collection", + "oneOf": [ + { + "type": "object", + "required": [ + "arguments", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "related" + ] + }, + "relationship": { + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unrelated" + ] + }, + "collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "Relationship": { + "title": "Relationship", + "type": "object", + "required": [ + "arguments", + "column_mapping", + "relationship_type", + "target_collection" + ], + "properties": { + "column_mapping": { + "description": "A mapping between columns on the source collection to columns on the target collection", + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "relationship_type": { + "$ref": "#/definitions/RelationshipType" + }, + "target_collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + "RelationshipType": { + "title": "Relationship Type", + "type": "string", + "enum": [ + "object", + "array" + ] + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/configuration/configuration.json b/crates/ndc-graphql/tests/config-3/configuration/configuration.json new file mode 100644 index 0000000..b8f9f3a --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/configuration/configuration.json @@ -0,0 +1,30 @@ +{ + "$schema": "configuration.schema.json", + "introspection": { + "endpoint": { + "valueFromEnv": "GRAPHQL_ENDPOINT" + }, + "headers": { + "x-hasura-admin-secret": { + "valueFromEnv": "GRAPHQL_ENDPOINT_SECRET" + } + } + }, + "execution": { + "endpoint": { + "valueFromEnv": "GRAPHQL_ENDPOINT" + }, + "headers": {} + }, + "request": { + "forwardHeaders": [ + "Authorization" + ], + "headersArgument": "_forwarded_headers" + }, + "response": { + "forwardHeaders": [ + "Set-Cookie" + ] + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/configuration/configuration.schema.json b/crates/ndc-graphql/tests/config-3/configuration/configuration.schema.json new file mode 100644 index 0000000..88c1025 --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/configuration/configuration.schema.json @@ -0,0 +1,168 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "ServerConfigFile", + "type": "object", + "required": [ + "$schema", + "execution", + "introspection", + "request", + "response" + ], + "properties": { + "$schema": { + "type": "string" + }, + "introspection": { + "description": "Connection Configuration for introspection", + "allOf": [ + { + "$ref": "#/definitions/ConnectionConfigFile" + } + ] + }, + "execution": { + "description": "Connection configuration for query execution", + "allOf": [ + { + "$ref": "#/definitions/ConnectionConfigFile" + } + ] + }, + "request": { + "description": "Optional configuration for requests", + "allOf": [ + { + "$ref": "#/definitions/RequestConfigFile" + } + ] + }, + "response": { + "description": "Optional configuration for responses", + "allOf": [ + { + "$ref": "#/definitions/ResponseConfigFile" + } + ] + } + }, + "definitions": { + "ConnectionConfigFile": { + "type": "object", + "required": [ + "endpoint" + ], + "properties": { + "endpoint": { + "$ref": "#/definitions/ConfigValue" + }, + "headers": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/ConfigValue" + } + } + } + }, + "ConfigValue": { + "oneOf": [ + { + "type": "object", + "required": [ + "value" + ], + "properties": { + "value": { + "type": "string" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "valueFromEnv" + ], + "properties": { + "valueFromEnv": { + "type": "string" + } + }, + "additionalProperties": false + } + ] + }, + "RequestConfigFile": { + "type": "object", + "properties": { + "headersArgument": { + "description": "Name of the headers argument Must not conflict with any arguments of root fields in the target schema Defaults to \"_headers\", set to a different value if there is a conflict", + "type": [ + "string", + "null" + ] + }, + "headersTypeName": { + "description": "Name of the headers argument type Must not conflict with other types in the target schema Defaults to \"_HeaderMap\", set to a different value if there is a conflict", + "type": [ + "string", + "null" + ] + }, + "forwardHeaders": { + "description": "List of headers to from the request Defaults to [], AKA no headers/disabled Supports glob patterns eg. \"X-Hasura-*\" Enabling this requires additional configuration on the ddn side, see docs for more", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + }, + "ResponseConfigFile": { + "type": "object", + "properties": { + "headersField": { + "description": "Name of the headers field in the response type Defaults to \"headers\"", + "type": [ + "string", + "null" + ] + }, + "responseField": { + "description": "Name of the response field in the response type Defaults to \"response\"", + "type": [ + "string", + "null" + ] + }, + "typeNamePrefix": { + "description": "Prefix for response type names Defaults to \"_\" Generated response type names must be unique once prefix and suffix are applied", + "type": [ + "string", + "null" + ] + }, + "typeNameSuffix": { + "description": "Suffix for response type names Defaults to \"Response\" Generated response type names must be unique once prefix and suffix are applied", + "type": [ + "string", + "null" + ] + }, + "forwardHeaders": { + "description": "List of headers to from the response Defaults to [], AKA no headers/disabled Supports glob patterns eg. \"X-Hasura-*\" Enabling this requires additional configuration on the ddn side, see docs for more", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/configuration/schema.graphql b/crates/ndc-graphql/tests/config-3/configuration/schema.graphql new file mode 100644 index 0000000..d301e54 --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/configuration/schema.graphql @@ -0,0 +1,3740 @@ +schema { + query: query_root + mutation: mutation_root +} + +"columns and relationships of \"Album\"" +type Album { + AlbumId: Int! + "An object relationship" + Artist: Artist! + ArtistId: Int! + Title: String! + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"Album\"" +type Album_aggregate { + aggregate: Album_aggregate_fields + nodes: [Album!]! +} + +input Album_aggregate_bool_exp { + count: Album_aggregate_bool_exp_count +} + +input Album_aggregate_bool_exp_count { + arguments: [Album_select_column!] + distinct: Boolean + filter: Album_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Album\"" +type Album_aggregate_fields { + avg: Album_avg_fields + count(columns: [Album_select_column!], distinct: Boolean): Int! + max: Album_max_fields + min: Album_min_fields + stddev: Album_stddev_fields + stddev_pop: Album_stddev_pop_fields + stddev_samp: Album_stddev_samp_fields + sum: Album_sum_fields + var_pop: Album_var_pop_fields + var_samp: Album_var_samp_fields + variance: Album_variance_fields +} + +"order by aggregate values of table \"Album\"" +input Album_aggregate_order_by { + avg: Album_avg_order_by + count: order_by + max: Album_max_order_by + min: Album_min_order_by + stddev: Album_stddev_order_by + stddev_pop: Album_stddev_pop_order_by + stddev_samp: Album_stddev_samp_order_by + sum: Album_sum_order_by + var_pop: Album_var_pop_order_by + var_samp: Album_var_samp_order_by + variance: Album_variance_order_by +} + +"input type for inserting array relation for remote table \"Album\"" +input Album_arr_rel_insert_input { + data: [Album_insert_input!]! + "upsert condition" on_conflict: Album_on_conflict +} + +"aggregate avg on columns" +type Album_avg_fields { + AlbumId: Float + ArtistId: Float +} + +"order by avg() on columns of table \"Album\"" +input Album_avg_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"Boolean expression to filter rows from the table \"Album\". All fields are combined with a logical 'AND'." +input Album_bool_exp { + AlbumId: Int_comparison_exp + Artist: Artist_bool_exp + ArtistId: Int_comparison_exp + Title: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [Album_bool_exp!] + _not: Album_bool_exp + _or: [Album_bool_exp!] +} + +"unique or primary key constraints on table \"Album\"" +enum Album_constraint { + "unique or primary key constraint on columns \"AlbumId\"" PK_Album +} + +"input type for incrementing numeric columns in table \"Album\"" +input Album_inc_input { + ArtistId: Int +} + +"input type for inserting data into table \"Album\"" +input Album_insert_input { + Artist: Artist_obj_rel_insert_input + ArtistId: Int + Title: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type Album_max_fields { + AlbumId: Int + ArtistId: Int + Title: String +} + +"order by max() on columns of table \"Album\"" +input Album_max_order_by { + AlbumId: order_by + ArtistId: order_by + Title: order_by +} + +"aggregate min on columns" +type Album_min_fields { + AlbumId: Int + ArtistId: Int + Title: String +} + +"order by min() on columns of table \"Album\"" +input Album_min_order_by { + AlbumId: order_by + ArtistId: order_by + Title: order_by +} + +"response of any mutation on the table \"Album\"" +type Album_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Album!]! +} + +"input type for inserting object relation for remote table \"Album\"" +input Album_obj_rel_insert_input { + data: Album_insert_input! + "upsert condition" on_conflict: Album_on_conflict +} + +"on_conflict condition type for table \"Album\"" +input Album_on_conflict { + constraint: Album_constraint! + update_columns: [Album_update_column!]! = [] + where: Album_bool_exp +} + +"Ordering options when selecting data from \"Album\"." +input Album_order_by { + AlbumId: order_by + Artist: Artist_order_by + ArtistId: order_by + Title: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: Album" +input Album_pk_columns_input { + AlbumId: Int! +} + +"select columns of table \"Album\"" +enum Album_select_column { + "column name" AlbumId + "column name" ArtistId + "column name" Title +} + +"input type for updating data in table \"Album\"" +input Album_set_input { + ArtistId: Int + Title: String +} + +"aggregate stddev on columns" +type Album_stddev_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev() on columns of table \"Album\"" +input Album_stddev_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate stddev_pop on columns" +type Album_stddev_pop_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev_pop() on columns of table \"Album\"" +input Album_stddev_pop_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate stddev_samp on columns" +type Album_stddev_samp_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev_samp() on columns of table \"Album\"" +input Album_stddev_samp_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"Streaming cursor of the table \"Album\"" +input Album_stream_cursor_input { + "Stream column input with initial value" initial_value: Album_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Album_stream_cursor_value_input { + AlbumId: Int + ArtistId: Int + Title: String +} + +"aggregate sum on columns" +type Album_sum_fields { + AlbumId: Int + ArtistId: Int +} + +"order by sum() on columns of table \"Album\"" +input Album_sum_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"update columns of table \"Album\"" +enum Album_update_column { + "column name" ArtistId + "column name" Title +} + +input Album_updates { + "increments the numeric columns with given value of the filtered values" _inc: Album_inc_input + "sets the columns of the filtered rows to the given values" _set: Album_set_input + "filter the rows which have to be updated" where: Album_bool_exp! +} + +"aggregate var_pop on columns" +type Album_var_pop_fields { + AlbumId: Float + ArtistId: Float +} + +"order by var_pop() on columns of table \"Album\"" +input Album_var_pop_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate var_samp on columns" +type Album_var_samp_fields { + AlbumId: Float + ArtistId: Float +} + +"order by var_samp() on columns of table \"Album\"" +input Album_var_samp_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate variance on columns" +type Album_variance_fields { + AlbumId: Float + ArtistId: Float +} + +"order by variance() on columns of table \"Album\"" +input Album_variance_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"columns and relationships of \"Artist\"" +type Artist { + "An array relationship" + Albums("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "An aggregate relationship" + Albums_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + ArtistId: Int! + Name: String +} + +"aggregated selection of \"Artist\"" +type Artist_aggregate { + aggregate: Artist_aggregate_fields + nodes: [Artist!]! +} + +"aggregate fields of \"Artist\"" +type Artist_aggregate_fields { + avg: Artist_avg_fields + count(columns: [Artist_select_column!], distinct: Boolean): Int! + max: Artist_max_fields + min: Artist_min_fields + stddev: Artist_stddev_fields + stddev_pop: Artist_stddev_pop_fields + stddev_samp: Artist_stddev_samp_fields + sum: Artist_sum_fields + var_pop: Artist_var_pop_fields + var_samp: Artist_var_samp_fields + variance: Artist_variance_fields +} + +"aggregate avg on columns" +type Artist_avg_fields { + ArtistId: Float +} + +"Boolean expression to filter rows from the table \"Artist\". All fields are combined with a logical 'AND'." +input Artist_bool_exp { + Albums: Album_bool_exp + Albums_aggregate: Album_aggregate_bool_exp + ArtistId: Int_comparison_exp + Name: String_comparison_exp + _and: [Artist_bool_exp!] + _not: Artist_bool_exp + _or: [Artist_bool_exp!] +} + +"unique or primary key constraints on table \"Artist\"" +enum Artist_constraint { + "unique or primary key constraint on columns \"ArtistId\"" PK_Artist +} + +"input type for inserting data into table \"Artist\"" +input Artist_insert_input { + Albums: Album_arr_rel_insert_input + Name: String +} + +"aggregate max on columns" +type Artist_max_fields { + ArtistId: Int + Name: String +} + +"aggregate min on columns" +type Artist_min_fields { + ArtistId: Int + Name: String +} + +"response of any mutation on the table \"Artist\"" +type Artist_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Artist!]! +} + +"input type for inserting object relation for remote table \"Artist\"" +input Artist_obj_rel_insert_input { + data: Artist_insert_input! + "upsert condition" on_conflict: Artist_on_conflict +} + +"on_conflict condition type for table \"Artist\"" +input Artist_on_conflict { + constraint: Artist_constraint! + update_columns: [Artist_update_column!]! = [] + where: Artist_bool_exp +} + +"Ordering options when selecting data from \"Artist\"." +input Artist_order_by { + Albums_aggregate: Album_aggregate_order_by + ArtistId: order_by + Name: order_by +} + +"primary key columns input for table: Artist" +input Artist_pk_columns_input { + ArtistId: Int! +} + +"select columns of table \"Artist\"" +enum Artist_select_column { + "column name" ArtistId + "column name" Name +} + +"input type for updating data in table \"Artist\"" +input Artist_set_input { + Name: String +} + +"aggregate stddev on columns" +type Artist_stddev_fields { + ArtistId: Float +} + +"aggregate stddev_pop on columns" +type Artist_stddev_pop_fields { + ArtistId: Float +} + +"aggregate stddev_samp on columns" +type Artist_stddev_samp_fields { + ArtistId: Float +} + +"Streaming cursor of the table \"Artist\"" +input Artist_stream_cursor_input { + "Stream column input with initial value" initial_value: Artist_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Artist_stream_cursor_value_input { + ArtistId: Int + Name: String +} + +"aggregate sum on columns" +type Artist_sum_fields { + ArtistId: Int +} + +"update columns of table \"Artist\"" +enum Artist_update_column { + "column name" Name +} + +input Artist_updates { + "sets the columns of the filtered rows to the given values" _set: Artist_set_input + "filter the rows which have to be updated" where: Artist_bool_exp! +} + +"aggregate var_pop on columns" +type Artist_var_pop_fields { + ArtistId: Float +} + +"aggregate var_samp on columns" +type Artist_var_samp_fields { + ArtistId: Float +} + +"aggregate variance on columns" +type Artist_variance_fields { + ArtistId: Float +} + +scalar Boolean + +"columns and relationships of \"Customer\"" +type Customer { + Address: String + City: String + Company: String + Country: String + CustomerId: Int! + Email: String! + "An object relationship" + Employee: Employee + Fax: String + FirstName: String! + "An array relationship" + Invoices("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "An aggregate relationship" + Invoices_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + LastName: String! + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregated selection of \"Customer\"" +type Customer_aggregate { + aggregate: Customer_aggregate_fields + nodes: [Customer!]! +} + +input Customer_aggregate_bool_exp { + count: Customer_aggregate_bool_exp_count +} + +input Customer_aggregate_bool_exp_count { + arguments: [Customer_select_column!] + distinct: Boolean + filter: Customer_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Customer\"" +type Customer_aggregate_fields { + avg: Customer_avg_fields + count(columns: [Customer_select_column!], distinct: Boolean): Int! + max: Customer_max_fields + min: Customer_min_fields + stddev: Customer_stddev_fields + stddev_pop: Customer_stddev_pop_fields + stddev_samp: Customer_stddev_samp_fields + sum: Customer_sum_fields + var_pop: Customer_var_pop_fields + var_samp: Customer_var_samp_fields + variance: Customer_variance_fields +} + +"order by aggregate values of table \"Customer\"" +input Customer_aggregate_order_by { + avg: Customer_avg_order_by + count: order_by + max: Customer_max_order_by + min: Customer_min_order_by + stddev: Customer_stddev_order_by + stddev_pop: Customer_stddev_pop_order_by + stddev_samp: Customer_stddev_samp_order_by + sum: Customer_sum_order_by + var_pop: Customer_var_pop_order_by + var_samp: Customer_var_samp_order_by + variance: Customer_variance_order_by +} + +"input type for inserting array relation for remote table \"Customer\"" +input Customer_arr_rel_insert_input { + data: [Customer_insert_input!]! + "upsert condition" on_conflict: Customer_on_conflict +} + +"aggregate avg on columns" +type Customer_avg_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by avg() on columns of table \"Customer\"" +input Customer_avg_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"Boolean expression to filter rows from the table \"Customer\". All fields are combined with a logical 'AND'." +input Customer_bool_exp { + Address: String_comparison_exp + City: String_comparison_exp + Company: String_comparison_exp + Country: String_comparison_exp + CustomerId: Int_comparison_exp + Email: String_comparison_exp + Employee: Employee_bool_exp + Fax: String_comparison_exp + FirstName: String_comparison_exp + Invoices: Invoice_bool_exp + Invoices_aggregate: Invoice_aggregate_bool_exp + LastName: String_comparison_exp + Phone: String_comparison_exp + PostalCode: String_comparison_exp + State: String_comparison_exp + SupportRepId: Int_comparison_exp + _and: [Customer_bool_exp!] + _not: Customer_bool_exp + _or: [Customer_bool_exp!] +} + +"unique or primary key constraints on table \"Customer\"" +enum Customer_constraint { + "unique or primary key constraint on columns \"CustomerId\"" PK_Customer +} + +"input type for incrementing numeric columns in table \"Customer\"" +input Customer_inc_input { + SupportRepId: Int +} + +"input type for inserting data into table \"Customer\"" +input Customer_insert_input { + Address: String + City: String + Company: String + Country: String + Email: String + Employee: Employee_obj_rel_insert_input + Fax: String + FirstName: String + Invoices: Invoice_arr_rel_insert_input + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate max on columns" +type Customer_max_fields { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"order by max() on columns of table \"Customer\"" +input Customer_max_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Fax: order_by + FirstName: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"aggregate min on columns" +type Customer_min_fields { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"order by min() on columns of table \"Customer\"" +input Customer_min_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Fax: order_by + FirstName: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"response of any mutation on the table \"Customer\"" +type Customer_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Customer!]! +} + +"input type for inserting object relation for remote table \"Customer\"" +input Customer_obj_rel_insert_input { + data: Customer_insert_input! + "upsert condition" on_conflict: Customer_on_conflict +} + +"on_conflict condition type for table \"Customer\"" +input Customer_on_conflict { + constraint: Customer_constraint! + update_columns: [Customer_update_column!]! = [] + where: Customer_bool_exp +} + +"Ordering options when selecting data from \"Customer\"." +input Customer_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Employee: Employee_order_by + Fax: order_by + FirstName: order_by + Invoices_aggregate: Invoice_aggregate_order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"primary key columns input for table: Customer" +input Customer_pk_columns_input { + CustomerId: Int! +} + +"select columns of table \"Customer\"" +enum Customer_select_column { + "column name" Address + "column name" City + "column name" Company + "column name" Country + "column name" CustomerId + "column name" Email + "column name" Fax + "column name" FirstName + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" State + "column name" SupportRepId +} + +"input type for updating data in table \"Customer\"" +input Customer_set_input { + Address: String + City: String + Company: String + Country: String + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate stddev on columns" +type Customer_stddev_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev() on columns of table \"Customer\"" +input Customer_stddev_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate stddev_pop on columns" +type Customer_stddev_pop_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev_pop() on columns of table \"Customer\"" +input Customer_stddev_pop_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate stddev_samp on columns" +type Customer_stddev_samp_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev_samp() on columns of table \"Customer\"" +input Customer_stddev_samp_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"Streaming cursor of the table \"Customer\"" +input Customer_stream_cursor_input { + "Stream column input with initial value" initial_value: Customer_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Customer_stream_cursor_value_input { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate sum on columns" +type Customer_sum_fields { + CustomerId: Int + SupportRepId: Int +} + +"order by sum() on columns of table \"Customer\"" +input Customer_sum_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"update columns of table \"Customer\"" +enum Customer_update_column { + "column name" Address + "column name" City + "column name" Company + "column name" Country + "column name" Email + "column name" Fax + "column name" FirstName + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" State + "column name" SupportRepId +} + +input Customer_updates { + "increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input + "sets the columns of the filtered rows to the given values" _set: Customer_set_input + "filter the rows which have to be updated" where: Customer_bool_exp! +} + +"aggregate var_pop on columns" +type Customer_var_pop_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by var_pop() on columns of table \"Customer\"" +input Customer_var_pop_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate var_samp on columns" +type Customer_var_samp_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by var_samp() on columns of table \"Customer\"" +input Customer_var_samp_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate variance on columns" +type Customer_variance_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by variance() on columns of table \"Customer\"" +input Customer_variance_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"columns and relationships of \"Employee\"" +type Employee { + Address: String + BirthDate: timestamp + City: String + Country: String + "An array relationship" + Customers("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "An aggregate relationship" + Customers_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + Email: String + "An object relationship" + Employee: Employee + EmployeeId: Int! + "An array relationship" + Employees("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "An aggregate relationship" + Employees_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + Fax: String + FirstName: String! + HireDate: timestamp + LastName: String! + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregated selection of \"Employee\"" +type Employee_aggregate { + aggregate: Employee_aggregate_fields + nodes: [Employee!]! +} + +input Employee_aggregate_bool_exp { + count: Employee_aggregate_bool_exp_count +} + +input Employee_aggregate_bool_exp_count { + arguments: [Employee_select_column!] + distinct: Boolean + filter: Employee_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Employee\"" +type Employee_aggregate_fields { + avg: Employee_avg_fields + count(columns: [Employee_select_column!], distinct: Boolean): Int! + max: Employee_max_fields + min: Employee_min_fields + stddev: Employee_stddev_fields + stddev_pop: Employee_stddev_pop_fields + stddev_samp: Employee_stddev_samp_fields + sum: Employee_sum_fields + var_pop: Employee_var_pop_fields + var_samp: Employee_var_samp_fields + variance: Employee_variance_fields +} + +"order by aggregate values of table \"Employee\"" +input Employee_aggregate_order_by { + avg: Employee_avg_order_by + count: order_by + max: Employee_max_order_by + min: Employee_min_order_by + stddev: Employee_stddev_order_by + stddev_pop: Employee_stddev_pop_order_by + stddev_samp: Employee_stddev_samp_order_by + sum: Employee_sum_order_by + var_pop: Employee_var_pop_order_by + var_samp: Employee_var_samp_order_by + variance: Employee_variance_order_by +} + +"input type for inserting array relation for remote table \"Employee\"" +input Employee_arr_rel_insert_input { + data: [Employee_insert_input!]! + "upsert condition" on_conflict: Employee_on_conflict +} + +"aggregate avg on columns" +type Employee_avg_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by avg() on columns of table \"Employee\"" +input Employee_avg_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"Boolean expression to filter rows from the table \"Employee\". All fields are combined with a logical 'AND'." +input Employee_bool_exp { + Address: String_comparison_exp + BirthDate: timestamp_comparison_exp + City: String_comparison_exp + Country: String_comparison_exp + Customers: Customer_bool_exp + Customers_aggregate: Customer_aggregate_bool_exp + Email: String_comparison_exp + Employee: Employee_bool_exp + EmployeeId: Int_comparison_exp + Employees: Employee_bool_exp + Employees_aggregate: Employee_aggregate_bool_exp + Fax: String_comparison_exp + FirstName: String_comparison_exp + HireDate: timestamp_comparison_exp + LastName: String_comparison_exp + Phone: String_comparison_exp + PostalCode: String_comparison_exp + ReportsTo: Int_comparison_exp + State: String_comparison_exp + Title: String_comparison_exp + _and: [Employee_bool_exp!] + _not: Employee_bool_exp + _or: [Employee_bool_exp!] +} + +"unique or primary key constraints on table \"Employee\"" +enum Employee_constraint { + "unique or primary key constraint on columns \"EmployeeId\"" PK_Employee +} + +"input type for incrementing numeric columns in table \"Employee\"" +input Employee_inc_input { + ReportsTo: Int +} + +"input type for inserting data into table \"Employee\"" +input Employee_insert_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Customers: Customer_arr_rel_insert_input + Email: String + Employee: Employee_obj_rel_insert_input + Employees: Employee_arr_rel_insert_input + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate max on columns" +type Employee_max_fields { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"order by max() on columns of table \"Employee\"" +input Employee_max_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Email: order_by + EmployeeId: order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"aggregate min on columns" +type Employee_min_fields { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"order by min() on columns of table \"Employee\"" +input Employee_min_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Email: order_by + EmployeeId: order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"response of any mutation on the table \"Employee\"" +type Employee_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Employee!]! +} + +"input type for inserting object relation for remote table \"Employee\"" +input Employee_obj_rel_insert_input { + data: Employee_insert_input! + "upsert condition" on_conflict: Employee_on_conflict +} + +"on_conflict condition type for table \"Employee\"" +input Employee_on_conflict { + constraint: Employee_constraint! + update_columns: [Employee_update_column!]! = [] + where: Employee_bool_exp +} + +"Ordering options when selecting data from \"Employee\"." +input Employee_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Customers_aggregate: Customer_aggregate_order_by + Email: order_by + Employee: Employee_order_by + EmployeeId: order_by + Employees_aggregate: Employee_aggregate_order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"primary key columns input for table: Employee" +input Employee_pk_columns_input { + EmployeeId: Int! +} + +"select columns of table \"Employee\"" +enum Employee_select_column { + "column name" Address + "column name" BirthDate + "column name" City + "column name" Country + "column name" Email + "column name" EmployeeId + "column name" Fax + "column name" FirstName + "column name" HireDate + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" ReportsTo + "column name" State + "column name" Title +} + +"input type for updating data in table \"Employee\"" +input Employee_set_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate stddev on columns" +type Employee_stddev_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev() on columns of table \"Employee\"" +input Employee_stddev_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate stddev_pop on columns" +type Employee_stddev_pop_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev_pop() on columns of table \"Employee\"" +input Employee_stddev_pop_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate stddev_samp on columns" +type Employee_stddev_samp_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev_samp() on columns of table \"Employee\"" +input Employee_stddev_samp_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"Streaming cursor of the table \"Employee\"" +input Employee_stream_cursor_input { + "Stream column input with initial value" initial_value: Employee_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Employee_stream_cursor_value_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate sum on columns" +type Employee_sum_fields { + EmployeeId: Int + ReportsTo: Int +} + +"order by sum() on columns of table \"Employee\"" +input Employee_sum_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"update columns of table \"Employee\"" +enum Employee_update_column { + "column name" Address + "column name" BirthDate + "column name" City + "column name" Country + "column name" Email + "column name" Fax + "column name" FirstName + "column name" HireDate + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" ReportsTo + "column name" State + "column name" Title +} + +input Employee_updates { + "increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input + "sets the columns of the filtered rows to the given values" _set: Employee_set_input + "filter the rows which have to be updated" where: Employee_bool_exp! +} + +"aggregate var_pop on columns" +type Employee_var_pop_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by var_pop() on columns of table \"Employee\"" +input Employee_var_pop_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate var_samp on columns" +type Employee_var_samp_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by var_samp() on columns of table \"Employee\"" +input Employee_var_samp_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate variance on columns" +type Employee_variance_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by variance() on columns of table \"Employee\"" +input Employee_variance_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +scalar Float + +"columns and relationships of \"Genre\"" +type Genre { + GenreId: Int! + Name: String + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"Genre\"" +type Genre_aggregate { + aggregate: Genre_aggregate_fields + nodes: [Genre!]! +} + +"aggregate fields of \"Genre\"" +type Genre_aggregate_fields { + avg: Genre_avg_fields + count(columns: [Genre_select_column!], distinct: Boolean): Int! + max: Genre_max_fields + min: Genre_min_fields + stddev: Genre_stddev_fields + stddev_pop: Genre_stddev_pop_fields + stddev_samp: Genre_stddev_samp_fields + sum: Genre_sum_fields + var_pop: Genre_var_pop_fields + var_samp: Genre_var_samp_fields + variance: Genre_variance_fields +} + +"aggregate avg on columns" +type Genre_avg_fields { + GenreId: Float +} + +"Boolean expression to filter rows from the table \"Genre\". All fields are combined with a logical 'AND'." +input Genre_bool_exp { + GenreId: Int_comparison_exp + Name: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [Genre_bool_exp!] + _not: Genre_bool_exp + _or: [Genre_bool_exp!] +} + +"unique or primary key constraints on table \"Genre\"" +enum Genre_constraint { + "unique or primary key constraint on columns \"GenreId\"" PK_Genre +} + +"input type for inserting data into table \"Genre\"" +input Genre_insert_input { + Name: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type Genre_max_fields { + GenreId: Int + Name: String +} + +"aggregate min on columns" +type Genre_min_fields { + GenreId: Int + Name: String +} + +"response of any mutation on the table \"Genre\"" +type Genre_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Genre!]! +} + +"input type for inserting object relation for remote table \"Genre\"" +input Genre_obj_rel_insert_input { + data: Genre_insert_input! + "upsert condition" on_conflict: Genre_on_conflict +} + +"on_conflict condition type for table \"Genre\"" +input Genre_on_conflict { + constraint: Genre_constraint! + update_columns: [Genre_update_column!]! = [] + where: Genre_bool_exp +} + +"Ordering options when selecting data from \"Genre\"." +input Genre_order_by { + GenreId: order_by + Name: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: Genre" +input Genre_pk_columns_input { + GenreId: Int! +} + +"select columns of table \"Genre\"" +enum Genre_select_column { + "column name" GenreId + "column name" Name +} + +"input type for updating data in table \"Genre\"" +input Genre_set_input { + Name: String +} + +"aggregate stddev on columns" +type Genre_stddev_fields { + GenreId: Float +} + +"aggregate stddev_pop on columns" +type Genre_stddev_pop_fields { + GenreId: Float +} + +"aggregate stddev_samp on columns" +type Genre_stddev_samp_fields { + GenreId: Float +} + +"Streaming cursor of the table \"Genre\"" +input Genre_stream_cursor_input { + "Stream column input with initial value" initial_value: Genre_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Genre_stream_cursor_value_input { + GenreId: Int + Name: String +} + +"aggregate sum on columns" +type Genre_sum_fields { + GenreId: Int +} + +"update columns of table \"Genre\"" +enum Genre_update_column { + "column name" Name +} + +input Genre_updates { + "sets the columns of the filtered rows to the given values" _set: Genre_set_input + "filter the rows which have to be updated" where: Genre_bool_exp! +} + +"aggregate var_pop on columns" +type Genre_var_pop_fields { + GenreId: Float +} + +"aggregate var_samp on columns" +type Genre_var_samp_fields { + GenreId: Float +} + +"aggregate variance on columns" +type Genre_variance_fields { + GenreId: Float +} + +scalar Int + +"Boolean expression to compare columns of type \"Int\". All fields are combined with logical 'AND'." +input Int_comparison_exp { + _eq: Int + _gt: Int + _gte: Int + _in: [Int!] + _is_null: Boolean + _lt: Int + _lte: Int + _neq: Int + _nin: [Int!] +} + +"columns and relationships of \"Invoice\"" +type Invoice { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + "An object relationship" + Customer: Customer! + CustomerId: Int! + InvoiceDate: timestamp! + InvoiceId: Int! + "An array relationship" + InvoiceLines("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "An aggregate relationship" + InvoiceLines_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + Total: numeric! +} + +"columns and relationships of \"InvoiceLine\"" +type InvoiceLine { + "An object relationship" + Invoice: Invoice! + InvoiceId: Int! + InvoiceLineId: Int! + Quantity: Int! + "An object relationship" + Track: Track! + TrackId: Int! + UnitPrice: numeric! +} + +"aggregated selection of \"InvoiceLine\"" +type InvoiceLine_aggregate { + aggregate: InvoiceLine_aggregate_fields + nodes: [InvoiceLine!]! +} + +input InvoiceLine_aggregate_bool_exp { + count: InvoiceLine_aggregate_bool_exp_count +} + +input InvoiceLine_aggregate_bool_exp_count { + arguments: [InvoiceLine_select_column!] + distinct: Boolean + filter: InvoiceLine_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"InvoiceLine\"" +type InvoiceLine_aggregate_fields { + avg: InvoiceLine_avg_fields + count(columns: [InvoiceLine_select_column!], distinct: Boolean): Int! + max: InvoiceLine_max_fields + min: InvoiceLine_min_fields + stddev: InvoiceLine_stddev_fields + stddev_pop: InvoiceLine_stddev_pop_fields + stddev_samp: InvoiceLine_stddev_samp_fields + sum: InvoiceLine_sum_fields + var_pop: InvoiceLine_var_pop_fields + var_samp: InvoiceLine_var_samp_fields + variance: InvoiceLine_variance_fields +} + +"order by aggregate values of table \"InvoiceLine\"" +input InvoiceLine_aggregate_order_by { + avg: InvoiceLine_avg_order_by + count: order_by + max: InvoiceLine_max_order_by + min: InvoiceLine_min_order_by + stddev: InvoiceLine_stddev_order_by + stddev_pop: InvoiceLine_stddev_pop_order_by + stddev_samp: InvoiceLine_stddev_samp_order_by + sum: InvoiceLine_sum_order_by + var_pop: InvoiceLine_var_pop_order_by + var_samp: InvoiceLine_var_samp_order_by + variance: InvoiceLine_variance_order_by +} + +"input type for inserting array relation for remote table \"InvoiceLine\"" +input InvoiceLine_arr_rel_insert_input { + data: [InvoiceLine_insert_input!]! + "upsert condition" on_conflict: InvoiceLine_on_conflict +} + +"aggregate avg on columns" +type InvoiceLine_avg_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by avg() on columns of table \"InvoiceLine\"" +input InvoiceLine_avg_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Boolean expression to filter rows from the table \"InvoiceLine\". All fields are combined with a logical 'AND'." +input InvoiceLine_bool_exp { + Invoice: Invoice_bool_exp + InvoiceId: Int_comparison_exp + InvoiceLineId: Int_comparison_exp + Quantity: Int_comparison_exp + Track: Track_bool_exp + TrackId: Int_comparison_exp + UnitPrice: numeric_comparison_exp + _and: [InvoiceLine_bool_exp!] + _not: InvoiceLine_bool_exp + _or: [InvoiceLine_bool_exp!] +} + +"unique or primary key constraints on table \"InvoiceLine\"" +enum InvoiceLine_constraint { + "unique or primary key constraint on columns \"InvoiceLineId\"" PK_InvoiceLine +} + +"input type for incrementing numeric columns in table \"InvoiceLine\"" +input InvoiceLine_inc_input { + InvoiceId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"input type for inserting data into table \"InvoiceLine\"" +input InvoiceLine_insert_input { + Invoice: Invoice_obj_rel_insert_input + InvoiceId: Int + Quantity: Int + Track: Track_obj_rel_insert_input + TrackId: Int + UnitPrice: numeric +} + +"aggregate max on columns" +type InvoiceLine_max_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by max() on columns of table \"InvoiceLine\"" +input InvoiceLine_max_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate min on columns" +type InvoiceLine_min_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by min() on columns of table \"InvoiceLine\"" +input InvoiceLine_min_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"response of any mutation on the table \"InvoiceLine\"" +type InvoiceLine_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [InvoiceLine!]! +} + +"on_conflict condition type for table \"InvoiceLine\"" +input InvoiceLine_on_conflict { + constraint: InvoiceLine_constraint! + update_columns: [InvoiceLine_update_column!]! = [] + where: InvoiceLine_bool_exp +} + +"Ordering options when selecting data from \"InvoiceLine\"." +input InvoiceLine_order_by { + Invoice: Invoice_order_by + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + Track: Track_order_by + TrackId: order_by + UnitPrice: order_by +} + +"primary key columns input for table: InvoiceLine" +input InvoiceLine_pk_columns_input { + InvoiceLineId: Int! +} + +"select columns of table \"InvoiceLine\"" +enum InvoiceLine_select_column { + "column name" InvoiceId + "column name" InvoiceLineId + "column name" Quantity + "column name" TrackId + "column name" UnitPrice +} + +"input type for updating data in table \"InvoiceLine\"" +input InvoiceLine_set_input { + InvoiceId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"aggregate stddev on columns" +type InvoiceLine_stddev_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_pop on columns" +type InvoiceLine_stddev_pop_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_pop() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_pop_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_samp on columns" +type InvoiceLine_stddev_samp_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_samp() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_samp_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Streaming cursor of the table \"InvoiceLine\"" +input InvoiceLine_stream_cursor_input { + "Stream column input with initial value" initial_value: InvoiceLine_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input InvoiceLine_stream_cursor_value_input { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"aggregate sum on columns" +type InvoiceLine_sum_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by sum() on columns of table \"InvoiceLine\"" +input InvoiceLine_sum_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"update columns of table \"InvoiceLine\"" +enum InvoiceLine_update_column { + "column name" InvoiceId + "column name" Quantity + "column name" TrackId + "column name" UnitPrice +} + +input InvoiceLine_updates { + "increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input + "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input + "filter the rows which have to be updated" where: InvoiceLine_bool_exp! +} + +"aggregate var_pop on columns" +type InvoiceLine_var_pop_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_pop() on columns of table \"InvoiceLine\"" +input InvoiceLine_var_pop_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate var_samp on columns" +type InvoiceLine_var_samp_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_samp() on columns of table \"InvoiceLine\"" +input InvoiceLine_var_samp_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate variance on columns" +type InvoiceLine_variance_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by variance() on columns of table \"InvoiceLine\"" +input InvoiceLine_variance_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregated selection of \"Invoice\"" +type Invoice_aggregate { + aggregate: Invoice_aggregate_fields + nodes: [Invoice!]! +} + +input Invoice_aggregate_bool_exp { + count: Invoice_aggregate_bool_exp_count +} + +input Invoice_aggregate_bool_exp_count { + arguments: [Invoice_select_column!] + distinct: Boolean + filter: Invoice_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Invoice\"" +type Invoice_aggregate_fields { + avg: Invoice_avg_fields + count(columns: [Invoice_select_column!], distinct: Boolean): Int! + max: Invoice_max_fields + min: Invoice_min_fields + stddev: Invoice_stddev_fields + stddev_pop: Invoice_stddev_pop_fields + stddev_samp: Invoice_stddev_samp_fields + sum: Invoice_sum_fields + var_pop: Invoice_var_pop_fields + var_samp: Invoice_var_samp_fields + variance: Invoice_variance_fields +} + +"order by aggregate values of table \"Invoice\"" +input Invoice_aggregate_order_by { + avg: Invoice_avg_order_by + count: order_by + max: Invoice_max_order_by + min: Invoice_min_order_by + stddev: Invoice_stddev_order_by + stddev_pop: Invoice_stddev_pop_order_by + stddev_samp: Invoice_stddev_samp_order_by + sum: Invoice_sum_order_by + var_pop: Invoice_var_pop_order_by + var_samp: Invoice_var_samp_order_by + variance: Invoice_variance_order_by +} + +"input type for inserting array relation for remote table \"Invoice\"" +input Invoice_arr_rel_insert_input { + data: [Invoice_insert_input!]! + "upsert condition" on_conflict: Invoice_on_conflict +} + +"aggregate avg on columns" +type Invoice_avg_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by avg() on columns of table \"Invoice\"" +input Invoice_avg_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"Boolean expression to filter rows from the table \"Invoice\". All fields are combined with a logical 'AND'." +input Invoice_bool_exp { + BillingAddress: String_comparison_exp + BillingCity: String_comparison_exp + BillingCountry: String_comparison_exp + BillingPostalCode: String_comparison_exp + BillingState: String_comparison_exp + Customer: Customer_bool_exp + CustomerId: Int_comparison_exp + InvoiceDate: timestamp_comparison_exp + InvoiceId: Int_comparison_exp + InvoiceLines: InvoiceLine_bool_exp + InvoiceLines_aggregate: InvoiceLine_aggregate_bool_exp + Total: numeric_comparison_exp + _and: [Invoice_bool_exp!] + _not: Invoice_bool_exp + _or: [Invoice_bool_exp!] +} + +"unique or primary key constraints on table \"Invoice\"" +enum Invoice_constraint { + "unique or primary key constraint on columns \"InvoiceId\"" PK_Invoice +} + +"input type for incrementing numeric columns in table \"Invoice\"" +input Invoice_inc_input { + CustomerId: Int + Total: numeric +} + +"input type for inserting data into table \"Invoice\"" +input Invoice_insert_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + Customer: Customer_obj_rel_insert_input + CustomerId: Int + InvoiceDate: timestamp + InvoiceLines: InvoiceLine_arr_rel_insert_input + Total: numeric +} + +"aggregate max on columns" +type Invoice_max_fields { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"order by max() on columns of table \"Invoice\"" +input Invoice_max_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate min on columns" +type Invoice_min_fields { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"order by min() on columns of table \"Invoice\"" +input Invoice_min_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + Total: order_by +} + +"response of any mutation on the table \"Invoice\"" +type Invoice_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Invoice!]! +} + +"input type for inserting object relation for remote table \"Invoice\"" +input Invoice_obj_rel_insert_input { + data: Invoice_insert_input! + "upsert condition" on_conflict: Invoice_on_conflict +} + +"on_conflict condition type for table \"Invoice\"" +input Invoice_on_conflict { + constraint: Invoice_constraint! + update_columns: [Invoice_update_column!]! = [] + where: Invoice_bool_exp +} + +"Ordering options when selecting data from \"Invoice\"." +input Invoice_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + Customer: Customer_order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + InvoiceLines_aggregate: InvoiceLine_aggregate_order_by + Total: order_by +} + +"primary key columns input for table: Invoice" +input Invoice_pk_columns_input { + InvoiceId: Int! +} + +"select columns of table \"Invoice\"" +enum Invoice_select_column { + "column name" BillingAddress + "column name" BillingCity + "column name" BillingCountry + "column name" BillingPostalCode + "column name" BillingState + "column name" CustomerId + "column name" InvoiceDate + "column name" InvoiceId + "column name" Total +} + +"input type for updating data in table \"Invoice\"" +input Invoice_set_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + Total: numeric +} + +"aggregate stddev on columns" +type Invoice_stddev_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev() on columns of table \"Invoice\"" +input Invoice_stddev_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate stddev_pop on columns" +type Invoice_stddev_pop_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev_pop() on columns of table \"Invoice\"" +input Invoice_stddev_pop_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate stddev_samp on columns" +type Invoice_stddev_samp_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev_samp() on columns of table \"Invoice\"" +input Invoice_stddev_samp_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"Streaming cursor of the table \"Invoice\"" +input Invoice_stream_cursor_input { + "Stream column input with initial value" initial_value: Invoice_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Invoice_stream_cursor_value_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"aggregate sum on columns" +type Invoice_sum_fields { + CustomerId: Int + InvoiceId: Int + Total: numeric +} + +"order by sum() on columns of table \"Invoice\"" +input Invoice_sum_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"update columns of table \"Invoice\"" +enum Invoice_update_column { + "column name" BillingAddress + "column name" BillingCity + "column name" BillingCountry + "column name" BillingPostalCode + "column name" BillingState + "column name" CustomerId + "column name" InvoiceDate + "column name" Total +} + +input Invoice_updates { + "increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input + "sets the columns of the filtered rows to the given values" _set: Invoice_set_input + "filter the rows which have to be updated" where: Invoice_bool_exp! +} + +"aggregate var_pop on columns" +type Invoice_var_pop_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by var_pop() on columns of table \"Invoice\"" +input Invoice_var_pop_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate var_samp on columns" +type Invoice_var_samp_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by var_samp() on columns of table \"Invoice\"" +input Invoice_var_samp_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate variance on columns" +type Invoice_variance_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by variance() on columns of table \"Invoice\"" +input Invoice_variance_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"columns and relationships of \"MediaType\"" +type MediaType { + MediaTypeId: Int! + Name: String + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"MediaType\"" +type MediaType_aggregate { + aggregate: MediaType_aggregate_fields + nodes: [MediaType!]! +} + +"aggregate fields of \"MediaType\"" +type MediaType_aggregate_fields { + avg: MediaType_avg_fields + count(columns: [MediaType_select_column!], distinct: Boolean): Int! + max: MediaType_max_fields + min: MediaType_min_fields + stddev: MediaType_stddev_fields + stddev_pop: MediaType_stddev_pop_fields + stddev_samp: MediaType_stddev_samp_fields + sum: MediaType_sum_fields + var_pop: MediaType_var_pop_fields + var_samp: MediaType_var_samp_fields + variance: MediaType_variance_fields +} + +"aggregate avg on columns" +type MediaType_avg_fields { + MediaTypeId: Float +} + +"Boolean expression to filter rows from the table \"MediaType\". All fields are combined with a logical 'AND'." +input MediaType_bool_exp { + MediaTypeId: Int_comparison_exp + Name: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [MediaType_bool_exp!] + _not: MediaType_bool_exp + _or: [MediaType_bool_exp!] +} + +"unique or primary key constraints on table \"MediaType\"" +enum MediaType_constraint { + "unique or primary key constraint on columns \"MediaTypeId\"" PK_MediaType +} + +"input type for inserting data into table \"MediaType\"" +input MediaType_insert_input { + Name: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type MediaType_max_fields { + MediaTypeId: Int + Name: String +} + +"aggregate min on columns" +type MediaType_min_fields { + MediaTypeId: Int + Name: String +} + +"response of any mutation on the table \"MediaType\"" +type MediaType_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [MediaType!]! +} + +"input type for inserting object relation for remote table \"MediaType\"" +input MediaType_obj_rel_insert_input { + data: MediaType_insert_input! + "upsert condition" on_conflict: MediaType_on_conflict +} + +"on_conflict condition type for table \"MediaType\"" +input MediaType_on_conflict { + constraint: MediaType_constraint! + update_columns: [MediaType_update_column!]! = [] + where: MediaType_bool_exp +} + +"Ordering options when selecting data from \"MediaType\"." +input MediaType_order_by { + MediaTypeId: order_by + Name: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: MediaType" +input MediaType_pk_columns_input { + MediaTypeId: Int! +} + +"select columns of table \"MediaType\"" +enum MediaType_select_column { + "column name" MediaTypeId + "column name" Name +} + +"input type for updating data in table \"MediaType\"" +input MediaType_set_input { + Name: String +} + +"aggregate stddev on columns" +type MediaType_stddev_fields { + MediaTypeId: Float +} + +"aggregate stddev_pop on columns" +type MediaType_stddev_pop_fields { + MediaTypeId: Float +} + +"aggregate stddev_samp on columns" +type MediaType_stddev_samp_fields { + MediaTypeId: Float +} + +"Streaming cursor of the table \"MediaType\"" +input MediaType_stream_cursor_input { + "Stream column input with initial value" initial_value: MediaType_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input MediaType_stream_cursor_value_input { + MediaTypeId: Int + Name: String +} + +"aggregate sum on columns" +type MediaType_sum_fields { + MediaTypeId: Int +} + +"update columns of table \"MediaType\"" +enum MediaType_update_column { + "column name" Name +} + +input MediaType_updates { + "sets the columns of the filtered rows to the given values" _set: MediaType_set_input + "filter the rows which have to be updated" where: MediaType_bool_exp! +} + +"aggregate var_pop on columns" +type MediaType_var_pop_fields { + MediaTypeId: Float +} + +"aggregate var_samp on columns" +type MediaType_var_samp_fields { + MediaTypeId: Float +} + +"aggregate variance on columns" +type MediaType_variance_fields { + MediaTypeId: Float +} + +"columns and relationships of \"Playlist\"" +type Playlist { + Name: String + PlaylistId: Int! + "An array relationship" + PlaylistTracks("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "An aggregate relationship" + PlaylistTracks_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! +} + +"columns and relationships of \"PlaylistTrack\"" +type PlaylistTrack { + "An object relationship" + Playlist: Playlist! + PlaylistId: Int! + "An object relationship" + Track: Track! + TrackId: Int! +} + +"aggregated selection of \"PlaylistTrack\"" +type PlaylistTrack_aggregate { + aggregate: PlaylistTrack_aggregate_fields + nodes: [PlaylistTrack!]! +} + +input PlaylistTrack_aggregate_bool_exp { + count: PlaylistTrack_aggregate_bool_exp_count +} + +input PlaylistTrack_aggregate_bool_exp_count { + arguments: [PlaylistTrack_select_column!] + distinct: Boolean + filter: PlaylistTrack_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"PlaylistTrack\"" +type PlaylistTrack_aggregate_fields { + avg: PlaylistTrack_avg_fields + count(columns: [PlaylistTrack_select_column!], distinct: Boolean): Int! + max: PlaylistTrack_max_fields + min: PlaylistTrack_min_fields + stddev: PlaylistTrack_stddev_fields + stddev_pop: PlaylistTrack_stddev_pop_fields + stddev_samp: PlaylistTrack_stddev_samp_fields + sum: PlaylistTrack_sum_fields + var_pop: PlaylistTrack_var_pop_fields + var_samp: PlaylistTrack_var_samp_fields + variance: PlaylistTrack_variance_fields +} + +"order by aggregate values of table \"PlaylistTrack\"" +input PlaylistTrack_aggregate_order_by { + avg: PlaylistTrack_avg_order_by + count: order_by + max: PlaylistTrack_max_order_by + min: PlaylistTrack_min_order_by + stddev: PlaylistTrack_stddev_order_by + stddev_pop: PlaylistTrack_stddev_pop_order_by + stddev_samp: PlaylistTrack_stddev_samp_order_by + sum: PlaylistTrack_sum_order_by + var_pop: PlaylistTrack_var_pop_order_by + var_samp: PlaylistTrack_var_samp_order_by + variance: PlaylistTrack_variance_order_by +} + +"input type for inserting array relation for remote table \"PlaylistTrack\"" +input PlaylistTrack_arr_rel_insert_input { + data: [PlaylistTrack_insert_input!]! + "upsert condition" on_conflict: PlaylistTrack_on_conflict +} + +"aggregate avg on columns" +type PlaylistTrack_avg_fields { + PlaylistId: Float + TrackId: Float +} + +"order by avg() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_avg_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"Boolean expression to filter rows from the table \"PlaylistTrack\". All fields are combined with a logical 'AND'." +input PlaylistTrack_bool_exp { + Playlist: Playlist_bool_exp + PlaylistId: Int_comparison_exp + Track: Track_bool_exp + TrackId: Int_comparison_exp + _and: [PlaylistTrack_bool_exp!] + _not: PlaylistTrack_bool_exp + _or: [PlaylistTrack_bool_exp!] +} + +"unique or primary key constraints on table \"PlaylistTrack\"" +enum PlaylistTrack_constraint { + "unique or primary key constraint on columns \"TrackId\", \"PlaylistId\"" PK_PlaylistTrack +} + +"input type for incrementing numeric columns in table \"PlaylistTrack\"" +input PlaylistTrack_inc_input { + PlaylistId: Int + TrackId: Int +} + +"input type for inserting data into table \"PlaylistTrack\"" +input PlaylistTrack_insert_input { + Playlist: Playlist_obj_rel_insert_input + PlaylistId: Int + Track: Track_obj_rel_insert_input + TrackId: Int +} + +"aggregate max on columns" +type PlaylistTrack_max_fields { + PlaylistId: Int + TrackId: Int +} + +"order by max() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_max_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate min on columns" +type PlaylistTrack_min_fields { + PlaylistId: Int + TrackId: Int +} + +"order by min() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_min_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"response of any mutation on the table \"PlaylistTrack\"" +type PlaylistTrack_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [PlaylistTrack!]! +} + +"on_conflict condition type for table \"PlaylistTrack\"" +input PlaylistTrack_on_conflict { + constraint: PlaylistTrack_constraint! + update_columns: [PlaylistTrack_update_column!]! = [] + where: PlaylistTrack_bool_exp +} + +"Ordering options when selecting data from \"PlaylistTrack\"." +input PlaylistTrack_order_by { + Playlist: Playlist_order_by + PlaylistId: order_by + Track: Track_order_by + TrackId: order_by +} + +"primary key columns input for table: PlaylistTrack" +input PlaylistTrack_pk_columns_input { + PlaylistId: Int! + TrackId: Int! +} + +"select columns of table \"PlaylistTrack\"" +enum PlaylistTrack_select_column { + "column name" PlaylistId + "column name" TrackId +} + +"input type for updating data in table \"PlaylistTrack\"" +input PlaylistTrack_set_input { + PlaylistId: Int + TrackId: Int +} + +"aggregate stddev on columns" +type PlaylistTrack_stddev_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate stddev_pop on columns" +type PlaylistTrack_stddev_pop_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev_pop() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_pop_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate stddev_samp on columns" +type PlaylistTrack_stddev_samp_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev_samp() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_samp_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"Streaming cursor of the table \"PlaylistTrack\"" +input PlaylistTrack_stream_cursor_input { + "Stream column input with initial value" initial_value: PlaylistTrack_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input PlaylistTrack_stream_cursor_value_input { + PlaylistId: Int + TrackId: Int +} + +"aggregate sum on columns" +type PlaylistTrack_sum_fields { + PlaylistId: Int + TrackId: Int +} + +"order by sum() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_sum_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"update columns of table \"PlaylistTrack\"" +enum PlaylistTrack_update_column { + "column name" PlaylistId + "column name" TrackId +} + +input PlaylistTrack_updates { + "increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input + "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input + "filter the rows which have to be updated" where: PlaylistTrack_bool_exp! +} + +"aggregate var_pop on columns" +type PlaylistTrack_var_pop_fields { + PlaylistId: Float + TrackId: Float +} + +"order by var_pop() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_var_pop_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate var_samp on columns" +type PlaylistTrack_var_samp_fields { + PlaylistId: Float + TrackId: Float +} + +"order by var_samp() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_var_samp_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate variance on columns" +type PlaylistTrack_variance_fields { + PlaylistId: Float + TrackId: Float +} + +"order by variance() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_variance_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregated selection of \"Playlist\"" +type Playlist_aggregate { + aggregate: Playlist_aggregate_fields + nodes: [Playlist!]! +} + +"aggregate fields of \"Playlist\"" +type Playlist_aggregate_fields { + avg: Playlist_avg_fields + count(columns: [Playlist_select_column!], distinct: Boolean): Int! + max: Playlist_max_fields + min: Playlist_min_fields + stddev: Playlist_stddev_fields + stddev_pop: Playlist_stddev_pop_fields + stddev_samp: Playlist_stddev_samp_fields + sum: Playlist_sum_fields + var_pop: Playlist_var_pop_fields + var_samp: Playlist_var_samp_fields + variance: Playlist_variance_fields +} + +"aggregate avg on columns" +type Playlist_avg_fields { + PlaylistId: Float +} + +"Boolean expression to filter rows from the table \"Playlist\". All fields are combined with a logical 'AND'." +input Playlist_bool_exp { + Name: String_comparison_exp + PlaylistId: Int_comparison_exp + PlaylistTracks: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: PlaylistTrack_aggregate_bool_exp + _and: [Playlist_bool_exp!] + _not: Playlist_bool_exp + _or: [Playlist_bool_exp!] +} + +"unique or primary key constraints on table \"Playlist\"" +enum Playlist_constraint { + "unique or primary key constraint on columns \"PlaylistId\"" PK_Playlist +} + +"input type for inserting data into table \"Playlist\"" +input Playlist_insert_input { + Name: String + PlaylistTracks: PlaylistTrack_arr_rel_insert_input +} + +"aggregate max on columns" +type Playlist_max_fields { + Name: String + PlaylistId: Int +} + +"aggregate min on columns" +type Playlist_min_fields { + Name: String + PlaylistId: Int +} + +"response of any mutation on the table \"Playlist\"" +type Playlist_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Playlist!]! +} + +"input type for inserting object relation for remote table \"Playlist\"" +input Playlist_obj_rel_insert_input { + data: Playlist_insert_input! + "upsert condition" on_conflict: Playlist_on_conflict +} + +"on_conflict condition type for table \"Playlist\"" +input Playlist_on_conflict { + constraint: Playlist_constraint! + update_columns: [Playlist_update_column!]! = [] + where: Playlist_bool_exp +} + +"Ordering options when selecting data from \"Playlist\"." +input Playlist_order_by { + Name: order_by + PlaylistId: order_by + PlaylistTracks_aggregate: PlaylistTrack_aggregate_order_by +} + +"primary key columns input for table: Playlist" +input Playlist_pk_columns_input { + PlaylistId: Int! +} + +"select columns of table \"Playlist\"" +enum Playlist_select_column { + "column name" Name + "column name" PlaylistId +} + +"input type for updating data in table \"Playlist\"" +input Playlist_set_input { + Name: String +} + +"aggregate stddev on columns" +type Playlist_stddev_fields { + PlaylistId: Float +} + +"aggregate stddev_pop on columns" +type Playlist_stddev_pop_fields { + PlaylistId: Float +} + +"aggregate stddev_samp on columns" +type Playlist_stddev_samp_fields { + PlaylistId: Float +} + +"Streaming cursor of the table \"Playlist\"" +input Playlist_stream_cursor_input { + "Stream column input with initial value" initial_value: Playlist_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Playlist_stream_cursor_value_input { + Name: String + PlaylistId: Int +} + +"aggregate sum on columns" +type Playlist_sum_fields { + PlaylistId: Int +} + +"update columns of table \"Playlist\"" +enum Playlist_update_column { + "column name" Name +} + +input Playlist_updates { + "sets the columns of the filtered rows to the given values" _set: Playlist_set_input + "filter the rows which have to be updated" where: Playlist_bool_exp! +} + +"aggregate var_pop on columns" +type Playlist_var_pop_fields { + PlaylistId: Float +} + +"aggregate var_samp on columns" +type Playlist_var_samp_fields { + PlaylistId: Float +} + +"aggregate variance on columns" +type Playlist_variance_fields { + PlaylistId: Float +} + +scalar String + +"Boolean expression to compare columns of type \"String\". All fields are combined with logical 'AND'." +input String_comparison_exp { + _eq: String + _gt: String + _gte: String + "does the column match the given case-insensitive pattern" _ilike: String + _in: [String!] + "does the column match the given POSIX regular expression, case insensitive" _iregex: String + _is_null: Boolean + "does the column match the given pattern" _like: String + _lt: String + _lte: String + _neq: String + "does the column NOT match the given case-insensitive pattern" _nilike: String + _nin: [String!] + "does the column NOT match the given POSIX regular expression, case insensitive" _niregex: String + "does the column NOT match the given pattern" _nlike: String + "does the column NOT match the given POSIX regular expression, case sensitive" _nregex: String + "does the column NOT match the given SQL regular expression" _nsimilar: String + "does the column match the given POSIX regular expression, case sensitive" _regex: String + "does the column match the given SQL regular expression" _similar: String +} + +"columns and relationships of \"Track\"" +type Track { + "An object relationship" + Album: Album + AlbumId: Int + Bytes: Int + Composer: String + "An object relationship" + Genre: Genre + GenreId: Int + "An array relationship" + InvoiceLines("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "An aggregate relationship" + InvoiceLines_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "An object relationship" + MediaType: MediaType! + MediaTypeId: Int! + Milliseconds: Int! + Name: String! + "An array relationship" + PlaylistTracks("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "An aggregate relationship" + PlaylistTracks_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + TrackId: Int! + UnitPrice: numeric! +} + +"aggregated selection of \"Track\"" +type Track_aggregate { + aggregate: Track_aggregate_fields + nodes: [Track!]! +} + +input Track_aggregate_bool_exp { + count: Track_aggregate_bool_exp_count +} + +input Track_aggregate_bool_exp_count { + arguments: [Track_select_column!] + distinct: Boolean + filter: Track_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Track\"" +type Track_aggregate_fields { + avg: Track_avg_fields + count(columns: [Track_select_column!], distinct: Boolean): Int! + max: Track_max_fields + min: Track_min_fields + stddev: Track_stddev_fields + stddev_pop: Track_stddev_pop_fields + stddev_samp: Track_stddev_samp_fields + sum: Track_sum_fields + var_pop: Track_var_pop_fields + var_samp: Track_var_samp_fields + variance: Track_variance_fields +} + +"order by aggregate values of table \"Track\"" +input Track_aggregate_order_by { + avg: Track_avg_order_by + count: order_by + max: Track_max_order_by + min: Track_min_order_by + stddev: Track_stddev_order_by + stddev_pop: Track_stddev_pop_order_by + stddev_samp: Track_stddev_samp_order_by + sum: Track_sum_order_by + var_pop: Track_var_pop_order_by + var_samp: Track_var_samp_order_by + variance: Track_variance_order_by +} + +"input type for inserting array relation for remote table \"Track\"" +input Track_arr_rel_insert_input { + data: [Track_insert_input!]! + "upsert condition" on_conflict: Track_on_conflict +} + +"aggregate avg on columns" +type Track_avg_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by avg() on columns of table \"Track\"" +input Track_avg_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Boolean expression to filter rows from the table \"Track\". All fields are combined with a logical 'AND'." +input Track_bool_exp { + Album: Album_bool_exp + AlbumId: Int_comparison_exp + Bytes: Int_comparison_exp + Composer: String_comparison_exp + Genre: Genre_bool_exp + GenreId: Int_comparison_exp + InvoiceLines: InvoiceLine_bool_exp + InvoiceLines_aggregate: InvoiceLine_aggregate_bool_exp + MediaType: MediaType_bool_exp + MediaTypeId: Int_comparison_exp + Milliseconds: Int_comparison_exp + Name: String_comparison_exp + PlaylistTracks: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: PlaylistTrack_aggregate_bool_exp + TrackId: Int_comparison_exp + UnitPrice: numeric_comparison_exp + _and: [Track_bool_exp!] + _not: Track_bool_exp + _or: [Track_bool_exp!] +} + +"unique or primary key constraints on table \"Track\"" +enum Track_constraint { + "unique or primary key constraint on columns \"TrackId\"" PK_Track +} + +"input type for incrementing numeric columns in table \"Track\"" +input Track_inc_input { + AlbumId: Int + Bytes: Int + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + UnitPrice: numeric +} + +"input type for inserting data into table \"Track\"" +input Track_insert_input { + Album: Album_obj_rel_insert_input + AlbumId: Int + Bytes: Int + Composer: String + Genre: Genre_obj_rel_insert_input + GenreId: Int + InvoiceLines: InvoiceLine_arr_rel_insert_input + MediaType: MediaType_obj_rel_insert_input + MediaTypeId: Int + Milliseconds: Int + Name: String + PlaylistTracks: PlaylistTrack_arr_rel_insert_input + UnitPrice: numeric +} + +"aggregate max on columns" +type Track_max_fields { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"order by max() on columns of table \"Track\"" +input Track_max_order_by { + AlbumId: order_by + Bytes: order_by + Composer: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate min on columns" +type Track_min_fields { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"order by min() on columns of table \"Track\"" +input Track_min_order_by { + AlbumId: order_by + Bytes: order_by + Composer: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + TrackId: order_by + UnitPrice: order_by +} + +"response of any mutation on the table \"Track\"" +type Track_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Track!]! +} + +"input type for inserting object relation for remote table \"Track\"" +input Track_obj_rel_insert_input { + data: Track_insert_input! + "upsert condition" on_conflict: Track_on_conflict +} + +"on_conflict condition type for table \"Track\"" +input Track_on_conflict { + constraint: Track_constraint! + update_columns: [Track_update_column!]! = [] + where: Track_bool_exp +} + +"Ordering options when selecting data from \"Track\"." +input Track_order_by { + Album: Album_order_by + AlbumId: order_by + Bytes: order_by + Composer: order_by + Genre: Genre_order_by + GenreId: order_by + InvoiceLines_aggregate: InvoiceLine_aggregate_order_by + MediaType: MediaType_order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + PlaylistTracks_aggregate: PlaylistTrack_aggregate_order_by + TrackId: order_by + UnitPrice: order_by +} + +"primary key columns input for table: Track" +input Track_pk_columns_input { + TrackId: Int! +} + +"select columns of table \"Track\"" +enum Track_select_column { + "column name" AlbumId + "column name" Bytes + "column name" Composer + "column name" GenreId + "column name" MediaTypeId + "column name" Milliseconds + "column name" Name + "column name" TrackId + "column name" UnitPrice +} + +"input type for updating data in table \"Track\"" +input Track_set_input { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + UnitPrice: numeric +} + +"aggregate stddev on columns" +type Track_stddev_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev() on columns of table \"Track\"" +input Track_stddev_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_pop on columns" +type Track_stddev_pop_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_pop() on columns of table \"Track\"" +input Track_stddev_pop_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_samp on columns" +type Track_stddev_samp_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_samp() on columns of table \"Track\"" +input Track_stddev_samp_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Streaming cursor of the table \"Track\"" +input Track_stream_cursor_input { + "Stream column input with initial value" initial_value: Track_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Track_stream_cursor_value_input { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"aggregate sum on columns" +type Track_sum_fields { + AlbumId: Int + Bytes: Int + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + TrackId: Int + UnitPrice: numeric +} + +"order by sum() on columns of table \"Track\"" +input Track_sum_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"update columns of table \"Track\"" +enum Track_update_column { + "column name" AlbumId + "column name" Bytes + "column name" Composer + "column name" GenreId + "column name" MediaTypeId + "column name" Milliseconds + "column name" Name + "column name" UnitPrice +} + +input Track_updates { + "increments the numeric columns with given value of the filtered values" _inc: Track_inc_input + "sets the columns of the filtered rows to the given values" _set: Track_set_input + "filter the rows which have to be updated" where: Track_bool_exp! +} + +"aggregate var_pop on columns" +type Track_var_pop_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_pop() on columns of table \"Track\"" +input Track_var_pop_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate var_samp on columns" +type Track_var_samp_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_samp() on columns of table \"Track\"" +input Track_var_samp_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate variance on columns" +type Track_variance_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by variance() on columns of table \"Track\"" +input Track_variance_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"ordering argument of a cursor" +enum cursor_ordering { + "ascending ordering of the cursor" ASC + "descending ordering of the cursor" DESC +} + +"mutation root" +type mutation_root { + "delete data from the table: \"Album\"" + delete_Album("filter the rows which have to be deleted" where: Album_bool_exp!): Album_mutation_response + "delete single row from the table: \"Album\"" + delete_Album_by_pk(AlbumId: Int!): Album + "delete data from the table: \"Artist\"" + delete_Artist("filter the rows which have to be deleted" where: Artist_bool_exp!): Artist_mutation_response + "delete single row from the table: \"Artist\"" + delete_Artist_by_pk(ArtistId: Int!): Artist + "delete data from the table: \"Customer\"" + delete_Customer("filter the rows which have to be deleted" where: Customer_bool_exp!): Customer_mutation_response + "delete single row from the table: \"Customer\"" + delete_Customer_by_pk(CustomerId: Int!): Customer + "delete data from the table: \"Employee\"" + delete_Employee("filter the rows which have to be deleted" where: Employee_bool_exp!): Employee_mutation_response + "delete single row from the table: \"Employee\"" + delete_Employee_by_pk(EmployeeId: Int!): Employee + "delete data from the table: \"Genre\"" + delete_Genre("filter the rows which have to be deleted" where: Genre_bool_exp!): Genre_mutation_response + "delete single row from the table: \"Genre\"" + delete_Genre_by_pk(GenreId: Int!): Genre + "delete data from the table: \"Invoice\"" + delete_Invoice("filter the rows which have to be deleted" where: Invoice_bool_exp!): Invoice_mutation_response + "delete data from the table: \"InvoiceLine\"" + delete_InvoiceLine("filter the rows which have to be deleted" where: InvoiceLine_bool_exp!): InvoiceLine_mutation_response + "delete single row from the table: \"InvoiceLine\"" + delete_InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "delete single row from the table: \"Invoice\"" + delete_Invoice_by_pk(InvoiceId: Int!): Invoice + "delete data from the table: \"MediaType\"" + delete_MediaType("filter the rows which have to be deleted" where: MediaType_bool_exp!): MediaType_mutation_response + "delete single row from the table: \"MediaType\"" + delete_MediaType_by_pk(MediaTypeId: Int!): MediaType + "delete data from the table: \"Playlist\"" + delete_Playlist("filter the rows which have to be deleted" where: Playlist_bool_exp!): Playlist_mutation_response + "delete data from the table: \"PlaylistTrack\"" + delete_PlaylistTrack("filter the rows which have to be deleted" where: PlaylistTrack_bool_exp!): PlaylistTrack_mutation_response + "delete single row from the table: \"PlaylistTrack\"" + delete_PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "delete single row from the table: \"Playlist\"" + delete_Playlist_by_pk(PlaylistId: Int!): Playlist + "delete data from the table: \"Track\"" + delete_Track("filter the rows which have to be deleted" where: Track_bool_exp!): Track_mutation_response + "delete single row from the table: \"Track\"" + delete_Track_by_pk(TrackId: Int!): Track + "insert data into the table: \"Album\"" + insert_Album("the rows to be inserted" objects: [Album_insert_input!]!, "upsert condition" on_conflict: Album_on_conflict): Album_mutation_response + "insert a single row into the table: \"Album\"" + insert_Album_one("the row to be inserted" object: Album_insert_input!, "upsert condition" on_conflict: Album_on_conflict): Album + "insert data into the table: \"Artist\"" + insert_Artist("the rows to be inserted" objects: [Artist_insert_input!]!, "upsert condition" on_conflict: Artist_on_conflict): Artist_mutation_response + "insert a single row into the table: \"Artist\"" + insert_Artist_one("the row to be inserted" object: Artist_insert_input!, "upsert condition" on_conflict: Artist_on_conflict): Artist + "insert data into the table: \"Customer\"" + insert_Customer("the rows to be inserted" objects: [Customer_insert_input!]!, "upsert condition" on_conflict: Customer_on_conflict): Customer_mutation_response + "insert a single row into the table: \"Customer\"" + insert_Customer_one("the row to be inserted" object: Customer_insert_input!, "upsert condition" on_conflict: Customer_on_conflict): Customer + "insert data into the table: \"Employee\"" + insert_Employee("the rows to be inserted" objects: [Employee_insert_input!]!, "upsert condition" on_conflict: Employee_on_conflict): Employee_mutation_response + "insert a single row into the table: \"Employee\"" + insert_Employee_one("the row to be inserted" object: Employee_insert_input!, "upsert condition" on_conflict: Employee_on_conflict): Employee + "insert data into the table: \"Genre\"" + insert_Genre("the rows to be inserted" objects: [Genre_insert_input!]!, "upsert condition" on_conflict: Genre_on_conflict): Genre_mutation_response + "insert a single row into the table: \"Genre\"" + insert_Genre_one("the row to be inserted" object: Genre_insert_input!, "upsert condition" on_conflict: Genre_on_conflict): Genre + "insert data into the table: \"Invoice\"" + insert_Invoice("the rows to be inserted" objects: [Invoice_insert_input!]!, "upsert condition" on_conflict: Invoice_on_conflict): Invoice_mutation_response + "insert data into the table: \"InvoiceLine\"" + insert_InvoiceLine("the rows to be inserted" objects: [InvoiceLine_insert_input!]!, "upsert condition" on_conflict: InvoiceLine_on_conflict): InvoiceLine_mutation_response + "insert a single row into the table: \"InvoiceLine\"" + insert_InvoiceLine_one("the row to be inserted" object: InvoiceLine_insert_input!, "upsert condition" on_conflict: InvoiceLine_on_conflict): InvoiceLine + "insert a single row into the table: \"Invoice\"" + insert_Invoice_one("the row to be inserted" object: Invoice_insert_input!, "upsert condition" on_conflict: Invoice_on_conflict): Invoice + "insert data into the table: \"MediaType\"" + insert_MediaType("the rows to be inserted" objects: [MediaType_insert_input!]!, "upsert condition" on_conflict: MediaType_on_conflict): MediaType_mutation_response + "insert a single row into the table: \"MediaType\"" + insert_MediaType_one("the row to be inserted" object: MediaType_insert_input!, "upsert condition" on_conflict: MediaType_on_conflict): MediaType + "insert data into the table: \"Playlist\"" + insert_Playlist("the rows to be inserted" objects: [Playlist_insert_input!]!, "upsert condition" on_conflict: Playlist_on_conflict): Playlist_mutation_response + "insert data into the table: \"PlaylistTrack\"" + insert_PlaylistTrack("the rows to be inserted" objects: [PlaylistTrack_insert_input!]!, "upsert condition" on_conflict: PlaylistTrack_on_conflict): PlaylistTrack_mutation_response + "insert a single row into the table: \"PlaylistTrack\"" + insert_PlaylistTrack_one("the row to be inserted" object: PlaylistTrack_insert_input!, "upsert condition" on_conflict: PlaylistTrack_on_conflict): PlaylistTrack + "insert a single row into the table: \"Playlist\"" + insert_Playlist_one("the row to be inserted" object: Playlist_insert_input!, "upsert condition" on_conflict: Playlist_on_conflict): Playlist + "insert data into the table: \"Track\"" + insert_Track("the rows to be inserted" objects: [Track_insert_input!]!, "upsert condition" on_conflict: Track_on_conflict): Track_mutation_response + "insert a single row into the table: \"Track\"" + insert_Track_one("the row to be inserted" object: Track_insert_input!, "upsert condition" on_conflict: Track_on_conflict): Track + "update data of the table: \"Album\"" + update_Album("increments the numeric columns with given value of the filtered values" _inc: Album_inc_input, "sets the columns of the filtered rows to the given values" _set: Album_set_input, "filter the rows which have to be updated" where: Album_bool_exp!): Album_mutation_response + "update single row of the table: \"Album\"" + update_Album_by_pk("increments the numeric columns with given value of the filtered values" _inc: Album_inc_input, "sets the columns of the filtered rows to the given values" _set: Album_set_input, pk_columns: Album_pk_columns_input!): Album + "update multiples rows of table: \"Album\"" + update_Album_many("updates to execute, in order" updates: [Album_updates!]!): [Album_mutation_response] + "update data of the table: \"Artist\"" + update_Artist("sets the columns of the filtered rows to the given values" _set: Artist_set_input, "filter the rows which have to be updated" where: Artist_bool_exp!): Artist_mutation_response + "update single row of the table: \"Artist\"" + update_Artist_by_pk("sets the columns of the filtered rows to the given values" _set: Artist_set_input, pk_columns: Artist_pk_columns_input!): Artist + "update multiples rows of table: \"Artist\"" + update_Artist_many("updates to execute, in order" updates: [Artist_updates!]!): [Artist_mutation_response] + "update data of the table: \"Customer\"" + update_Customer("increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input, "sets the columns of the filtered rows to the given values" _set: Customer_set_input, "filter the rows which have to be updated" where: Customer_bool_exp!): Customer_mutation_response + "update single row of the table: \"Customer\"" + update_Customer_by_pk("increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input, "sets the columns of the filtered rows to the given values" _set: Customer_set_input, pk_columns: Customer_pk_columns_input!): Customer + "update multiples rows of table: \"Customer\"" + update_Customer_many("updates to execute, in order" updates: [Customer_updates!]!): [Customer_mutation_response] + "update data of the table: \"Employee\"" + update_Employee("increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input, "sets the columns of the filtered rows to the given values" _set: Employee_set_input, "filter the rows which have to be updated" where: Employee_bool_exp!): Employee_mutation_response + "update single row of the table: \"Employee\"" + update_Employee_by_pk("increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input, "sets the columns of the filtered rows to the given values" _set: Employee_set_input, pk_columns: Employee_pk_columns_input!): Employee + "update multiples rows of table: \"Employee\"" + update_Employee_many("updates to execute, in order" updates: [Employee_updates!]!): [Employee_mutation_response] + "update data of the table: \"Genre\"" + update_Genre("sets the columns of the filtered rows to the given values" _set: Genre_set_input, "filter the rows which have to be updated" where: Genre_bool_exp!): Genre_mutation_response + "update single row of the table: \"Genre\"" + update_Genre_by_pk("sets the columns of the filtered rows to the given values" _set: Genre_set_input, pk_columns: Genre_pk_columns_input!): Genre + "update multiples rows of table: \"Genre\"" + update_Genre_many("updates to execute, in order" updates: [Genre_updates!]!): [Genre_mutation_response] + "update data of the table: \"Invoice\"" + update_Invoice("increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input, "sets the columns of the filtered rows to the given values" _set: Invoice_set_input, "filter the rows which have to be updated" where: Invoice_bool_exp!): Invoice_mutation_response + "update data of the table: \"InvoiceLine\"" + update_InvoiceLine("increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input, "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input, "filter the rows which have to be updated" where: InvoiceLine_bool_exp!): InvoiceLine_mutation_response + "update single row of the table: \"InvoiceLine\"" + update_InvoiceLine_by_pk("increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input, "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input, pk_columns: InvoiceLine_pk_columns_input!): InvoiceLine + "update multiples rows of table: \"InvoiceLine\"" + update_InvoiceLine_many("updates to execute, in order" updates: [InvoiceLine_updates!]!): [InvoiceLine_mutation_response] + "update single row of the table: \"Invoice\"" + update_Invoice_by_pk("increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input, "sets the columns of the filtered rows to the given values" _set: Invoice_set_input, pk_columns: Invoice_pk_columns_input!): Invoice + "update multiples rows of table: \"Invoice\"" + update_Invoice_many("updates to execute, in order" updates: [Invoice_updates!]!): [Invoice_mutation_response] + "update data of the table: \"MediaType\"" + update_MediaType("sets the columns of the filtered rows to the given values" _set: MediaType_set_input, "filter the rows which have to be updated" where: MediaType_bool_exp!): MediaType_mutation_response + "update single row of the table: \"MediaType\"" + update_MediaType_by_pk("sets the columns of the filtered rows to the given values" _set: MediaType_set_input, pk_columns: MediaType_pk_columns_input!): MediaType + "update multiples rows of table: \"MediaType\"" + update_MediaType_many("updates to execute, in order" updates: [MediaType_updates!]!): [MediaType_mutation_response] + "update data of the table: \"Playlist\"" + update_Playlist("sets the columns of the filtered rows to the given values" _set: Playlist_set_input, "filter the rows which have to be updated" where: Playlist_bool_exp!): Playlist_mutation_response + "update data of the table: \"PlaylistTrack\"" + update_PlaylistTrack("increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input, "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input, "filter the rows which have to be updated" where: PlaylistTrack_bool_exp!): PlaylistTrack_mutation_response + "update single row of the table: \"PlaylistTrack\"" + update_PlaylistTrack_by_pk("increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input, "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input, pk_columns: PlaylistTrack_pk_columns_input!): PlaylistTrack + "update multiples rows of table: \"PlaylistTrack\"" + update_PlaylistTrack_many("updates to execute, in order" updates: [PlaylistTrack_updates!]!): [PlaylistTrack_mutation_response] + "update single row of the table: \"Playlist\"" + update_Playlist_by_pk("sets the columns of the filtered rows to the given values" _set: Playlist_set_input, pk_columns: Playlist_pk_columns_input!): Playlist + "update multiples rows of table: \"Playlist\"" + update_Playlist_many("updates to execute, in order" updates: [Playlist_updates!]!): [Playlist_mutation_response] + "update data of the table: \"Track\"" + update_Track("increments the numeric columns with given value of the filtered values" _inc: Track_inc_input, "sets the columns of the filtered rows to the given values" _set: Track_set_input, "filter the rows which have to be updated" where: Track_bool_exp!): Track_mutation_response + "update single row of the table: \"Track\"" + update_Track_by_pk("increments the numeric columns with given value of the filtered values" _inc: Track_inc_input, "sets the columns of the filtered rows to the given values" _set: Track_set_input, pk_columns: Track_pk_columns_input!): Track + "update multiples rows of table: \"Track\"" + update_Track_many("updates to execute, in order" updates: [Track_updates!]!): [Track_mutation_response] +} + +scalar numeric + +"Boolean expression to compare columns of type \"numeric\". All fields are combined with logical 'AND'." +input numeric_comparison_exp { + _eq: numeric + _gt: numeric + _gte: numeric + _in: [numeric!] + _is_null: Boolean + _lt: numeric + _lte: numeric + _neq: numeric + _nin: [numeric!] +} + +"column ordering options" +enum order_by { + "in ascending order, nulls last" asc + "in ascending order, nulls first" asc_nulls_first + "in ascending order, nulls last" asc_nulls_last + "in descending order, nulls first" desc + "in descending order, nulls first" desc_nulls_first + "in descending order, nulls last" desc_nulls_last +} + +type query_root { + "fetch data from the table: \"Album\"" + Album("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch aggregated fields from the table: \"Album\"" + Album_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + "fetch data from the table: \"Album\" using primary key columns" + Album_by_pk(AlbumId: Int!): Album + "fetch data from the table: \"Artist\"" + Artist("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch aggregated fields from the table: \"Artist\"" + Artist_aggregate("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): Artist_aggregate! + "fetch data from the table: \"Artist\" using primary key columns" + Artist_by_pk(ArtistId: Int!): Artist + "fetch data from the table: \"Customer\"" + Customer("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch aggregated fields from the table: \"Customer\"" + Customer_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + "fetch data from the table: \"Customer\" using primary key columns" + Customer_by_pk(CustomerId: Int!): Customer + "fetch data from the table: \"Employee\"" + Employee("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch aggregated fields from the table: \"Employee\"" + Employee_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + "fetch data from the table: \"Employee\" using primary key columns" + Employee_by_pk(EmployeeId: Int!): Employee + "fetch data from the table: \"Genre\"" + Genre("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch aggregated fields from the table: \"Genre\"" + Genre_aggregate("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): Genre_aggregate! + "fetch data from the table: \"Genre\" using primary key columns" + Genre_by_pk(GenreId: Int!): Genre + "fetch data from the table: \"Invoice\"" + Invoice("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"InvoiceLine\"" + InvoiceLine("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"InvoiceLine\"" + InvoiceLine_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "fetch data from the table: \"InvoiceLine\" using primary key columns" + InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "fetch aggregated fields from the table: \"Invoice\"" + Invoice_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + "fetch data from the table: \"Invoice\" using primary key columns" + Invoice_by_pk(InvoiceId: Int!): Invoice + "fetch data from the table: \"MediaType\"" + MediaType("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch aggregated fields from the table: \"MediaType\"" + MediaType_aggregate("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): MediaType_aggregate! + "fetch data from the table: \"MediaType\" using primary key columns" + MediaType_by_pk(MediaTypeId: Int!): MediaType + "fetch data from the table: \"Playlist\"" + Playlist("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"PlaylistTrack\"" + PlaylistTrack("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"PlaylistTrack\"" + PlaylistTrack_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + "fetch data from the table: \"PlaylistTrack\" using primary key columns" + PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "fetch aggregated fields from the table: \"Playlist\"" + Playlist_aggregate("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): Playlist_aggregate! + "fetch data from the table: \"Playlist\" using primary key columns" + Playlist_by_pk(PlaylistId: Int!): Playlist + "fetch data from the table: \"Track\"" + Track("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "fetch aggregated fields from the table: \"Track\"" + Track_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! + "fetch data from the table: \"Track\" using primary key columns" + Track_by_pk(TrackId: Int!): Track +} + +type subscription_root { + "fetch data from the table: \"Album\"" + Album("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch aggregated fields from the table: \"Album\"" + Album_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + "fetch data from the table: \"Album\" using primary key columns" + Album_by_pk(AlbumId: Int!): Album + "fetch data from the table in a streaming manner: \"Album\"" + Album_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Album_stream_cursor_input]!, "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch data from the table: \"Artist\"" + Artist("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch aggregated fields from the table: \"Artist\"" + Artist_aggregate("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): Artist_aggregate! + "fetch data from the table: \"Artist\" using primary key columns" + Artist_by_pk(ArtistId: Int!): Artist + "fetch data from the table in a streaming manner: \"Artist\"" + Artist_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Artist_stream_cursor_input]!, "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch data from the table: \"Customer\"" + Customer("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch aggregated fields from the table: \"Customer\"" + Customer_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + "fetch data from the table: \"Customer\" using primary key columns" + Customer_by_pk(CustomerId: Int!): Customer + "fetch data from the table in a streaming manner: \"Customer\"" + Customer_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Customer_stream_cursor_input]!, "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch data from the table: \"Employee\"" + Employee("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch aggregated fields from the table: \"Employee\"" + Employee_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + "fetch data from the table: \"Employee\" using primary key columns" + Employee_by_pk(EmployeeId: Int!): Employee + "fetch data from the table in a streaming manner: \"Employee\"" + Employee_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Employee_stream_cursor_input]!, "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch data from the table: \"Genre\"" + Genre("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch aggregated fields from the table: \"Genre\"" + Genre_aggregate("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): Genre_aggregate! + "fetch data from the table: \"Genre\" using primary key columns" + Genre_by_pk(GenreId: Int!): Genre + "fetch data from the table in a streaming manner: \"Genre\"" + Genre_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Genre_stream_cursor_input]!, "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch data from the table: \"Invoice\"" + Invoice("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"InvoiceLine\"" + InvoiceLine("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"InvoiceLine\"" + InvoiceLine_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "fetch data from the table: \"InvoiceLine\" using primary key columns" + InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "fetch data from the table in a streaming manner: \"InvoiceLine\"" + InvoiceLine_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [InvoiceLine_stream_cursor_input]!, "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"Invoice\"" + Invoice_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + "fetch data from the table: \"Invoice\" using primary key columns" + Invoice_by_pk(InvoiceId: Int!): Invoice + "fetch data from the table in a streaming manner: \"Invoice\"" + Invoice_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Invoice_stream_cursor_input]!, "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"MediaType\"" + MediaType("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch aggregated fields from the table: \"MediaType\"" + MediaType_aggregate("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): MediaType_aggregate! + "fetch data from the table: \"MediaType\" using primary key columns" + MediaType_by_pk(MediaTypeId: Int!): MediaType + "fetch data from the table in a streaming manner: \"MediaType\"" + MediaType_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [MediaType_stream_cursor_input]!, "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch data from the table: \"Playlist\"" + Playlist("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"PlaylistTrack\"" + PlaylistTrack("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"PlaylistTrack\"" + PlaylistTrack_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + "fetch data from the table: \"PlaylistTrack\" using primary key columns" + PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "fetch data from the table in a streaming manner: \"PlaylistTrack\"" + PlaylistTrack_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [PlaylistTrack_stream_cursor_input]!, "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"Playlist\"" + Playlist_aggregate("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): Playlist_aggregate! + "fetch data from the table: \"Playlist\" using primary key columns" + Playlist_by_pk(PlaylistId: Int!): Playlist + "fetch data from the table in a streaming manner: \"Playlist\"" + Playlist_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Playlist_stream_cursor_input]!, "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"Track\"" + Track("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "fetch aggregated fields from the table: \"Track\"" + Track_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! + "fetch data from the table: \"Track\" using primary key columns" + Track_by_pk(TrackId: Int!): Track + "fetch data from the table in a streaming manner: \"Track\"" + Track_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Track_stream_cursor_input]!, "filter the rows returned" where: Track_bool_exp): [Track!]! +} + +scalar timestamp + +"Boolean expression to compare columns of type \"timestamp\". All fields are combined with logical 'AND'." +input timestamp_comparison_exp { + _eq: timestamp + _gt: timestamp + _gte: timestamp + _in: [timestamp!] + _is_null: Boolean + _lt: timestamp + _lte: timestamp + _neq: timestamp + _nin: [timestamp!] +} diff --git a/crates/ndc-graphql/tests/config-3/mutations/01_single_operation.request.json b/crates/ndc-graphql/tests/config-3/mutations/01_single_operation.request.json new file mode 100644 index 0000000..72ce96a --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/mutations/01_single_operation.request.json @@ -0,0 +1,36 @@ +{ + "$schema": "_mutation_request.schema.json", + "operations": [ + { + "type": "procedure", + "name": "update_Album_by_pk", + "arguments": { + "_set": { + "ArtistId": 1 + }, + "pk_columns": { + "AlbumId": 1 + }, + "_forwarded_headers": { + "Authorization": "Bearer " + } + }, + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + } + } + } + } + ], + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/mutations/02_multiple_operations.request.json b/crates/ndc-graphql/tests/config-3/mutations/02_multiple_operations.request.json new file mode 100644 index 0000000..d06a908 --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/mutations/02_multiple_operations.request.json @@ -0,0 +1,62 @@ +{ + "operations": [ + { + "type": "procedure", + "name": "update_Album_by_pk", + "arguments": { + "_set": { + "ArtistId": 1 + }, + "pk_columns": { + "AlbumId": 1 + }, + "_forwarded_headers": { + "Authorization": "Bearer " + } + }, + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + } + } + } + }, + { + "type": "procedure", + "name": "update_Album_by_pk", + "arguments": { + "_set": { + "ArtistId": 1 + }, + "pk_columns": { + "AlbumId": 1 + } + }, + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + } + } + } + } + ], + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/mutations/_mutation_request.schema.json b/crates/ndc-graphql/tests/config-3/mutations/_mutation_request.schema.json new file mode 100644 index 0000000..4ccdb61 --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/mutations/_mutation_request.schema.json @@ -0,0 +1,989 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Mutation Request", + "type": "object", + "required": [ + "collection_relationships", + "operations" + ], + "properties": { + "operations": { + "description": "The mutation operations to perform", + "type": "array", + "items": { + "$ref": "#/definitions/MutationOperation" + } + }, + "collection_relationships": { + "description": "The relationships between collections involved in the entire mutation request", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Relationship" + } + } + }, + "definitions": { + "MutationOperation": { + "title": "Mutation Operation", + "oneOf": [ + { + "type": "object", + "required": [ + "arguments", + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "procedure" + ] + }, + "name": { + "description": "The name of a procedure", + "type": "string" + }, + "arguments": { + "description": "Any named procedure arguments", + "type": "object", + "additionalProperties": true + }, + "fields": { + "description": "The fields to return from the result, or null to return everything", + "anyOf": [ + { + "$ref": "#/definitions/NestedField" + }, + { + "type": "null" + } + ] + } + } + } + ] + }, + "NestedField": { + "title": "NestedField", + "oneOf": [ + { + "title": "NestedObject", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "object" + ] + }, + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Field" + } + } + } + }, + { + "title": "NestedArray", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "array" + ] + }, + "fields": { + "$ref": "#/definitions/NestedField" + } + } + } + ] + }, + "Field": { + "title": "Field", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "type": "string" + }, + "fields": { + "description": "When the type of the column is a (possibly-nullable) array or object, the caller can request a subset of the complete column data, by specifying fields to fetch here. If omitted, the column data will be fetched in full.", + "anyOf": [ + { + "$ref": "#/definitions/NestedField" + }, + { + "type": "null" + } + ] + }, + "arguments": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Argument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "query", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "relationship" + ] + }, + "query": { + "$ref": "#/definitions/Query" + }, + "relationship": { + "description": "The name of the relationship to follow for the subquery", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "Argument": { + "title": "Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + } + ] + }, + "Query": { + "title": "Query", + "type": "object", + "properties": { + "aggregates": { + "description": "Aggregate fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Aggregate" + } + }, + "fields": { + "description": "Fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Field" + } + }, + "limit": { + "description": "Optionally limit to N results", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "offset": { + "description": "Optionally offset from the Nth result", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "order_by": { + "anyOf": [ + { + "$ref": "#/definitions/OrderBy" + }, + { + "type": "null" + } + ] + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "Aggregate": { + "title": "Aggregate", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "distinct", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column_count" + ] + }, + "column": { + "description": "The column to apply the count aggregate function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "distinct": { + "description": "Whether or not only distinct items should be counted", + "type": "boolean" + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count" + ] + } + } + } + ] + }, + "OrderBy": { + "title": "Order By", + "type": "object", + "required": [ + "elements" + ], + "properties": { + "elements": { + "description": "The elements to order by, in priority order", + "type": "array", + "items": { + "$ref": "#/definitions/OrderByElement" + } + } + } + }, + "OrderByElement": { + "title": "Order By Element", + "type": "object", + "required": [ + "order_direction", + "target" + ], + "properties": { + "order_direction": { + "$ref": "#/definitions/OrderDirection" + }, + "target": { + "$ref": "#/definitions/OrderByTarget" + } + } + }, + "OrderDirection": { + "title": "Order Direction", + "type": "string", + "enum": [ + "asc", + "desc" + ] + }, + "OrderByTarget": { + "title": "Order By Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column_aggregate" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count_aggregate" + ] + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + } + ] + }, + "PathElement": { + "title": "Path Element", + "type": "object", + "required": [ + "arguments", + "relationship" + ], + "properties": { + "relationship": { + "description": "The name of the relationship to follow", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + }, + "predicate": { + "description": "A predicate expression to apply to the target collection", + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "RelationshipArgument": { + "title": "Relationship Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "Expression": { + "title": "Expression", + "oneOf": [ + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "and" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "or" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expression", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "not" + ] + }, + "expression": { + "$ref": "#/definitions/Expression" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "$ref": "#/definitions/UnaryComparisonOperator" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "binary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/ComparisonValue" + } + } + }, + { + "type": "object", + "required": [ + "in_collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "exists" + ] + }, + "in_collection": { + "$ref": "#/definitions/ExistsInCollection" + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + } + ] + }, + "ComparisonTarget": { + "title": "Comparison Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "root_collection_column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + ] + }, + "UnaryComparisonOperator": { + "title": "Unary Comparison Operator", + "type": "string", + "enum": [ + "is_null" + ] + }, + "ComparisonValue": { + "title": "Comparison Value", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + } + } + }, + { + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "scalar" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "ExistsInCollection": { + "title": "Exists In Collection", + "oneOf": [ + { + "type": "object", + "required": [ + "arguments", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "related" + ] + }, + "relationship": { + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unrelated" + ] + }, + "collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "Relationship": { + "title": "Relationship", + "type": "object", + "required": [ + "arguments", + "column_mapping", + "relationship_type", + "target_collection" + ], + "properties": { + "column_mapping": { + "description": "A mapping between columns on the source collection to columns on the target collection", + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "relationship_type": { + "$ref": "#/definitions/RelationshipType" + }, + "target_collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + "RelationshipType": { + "title": "Relationship Type", + "type": "string", + "enum": [ + "object", + "array" + ] + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/queries/01_basic_query.request.json b/crates/ndc-graphql/tests/config-3/queries/01_basic_query.request.json new file mode 100644 index 0000000..fe5a81c --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/queries/01_basic_query.request.json @@ -0,0 +1,104 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album", + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + }, + "MediaType": { + "type": "column", + "column": "MediaType", + "fields": { + "type": "object", + "fields": { + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "MediaTypeId": { + "type": "column", + "column": "MediaTypeId", + "fields": null + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "arguments": { + "_forwarded_headers": { + "type": "literal", + "value": { + "Authorization": "Bearer " + } + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/queries/02_root_node_parameters.request.json b/crates/ndc-graphql/tests/config-3/queries/02_root_node_parameters.request.json new file mode 100644 index 0000000..1845db1 --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/queries/02_root_node_parameters.request.json @@ -0,0 +1,116 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album", + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + }, + "MediaType": { + "type": "column", + "column": "MediaType", + "fields": { + "type": "object", + "fields": { + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "MediaTypeId": { + "type": "column", + "column": "MediaTypeId", + "fields": null + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "arguments": { + "limit": { + "type": "literal", + "value": 20 + }, + "where": { + "type": "literal", + "value": { + "AlbumId": { + "_gt": 5 + } + } + }, + "_forwarded_headers": { + "type": "literal", + "value": { + "Authorization": "Bearer " + } + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/queries/03_child_node_parameters.request.json b/crates/ndc-graphql/tests/config-3/queries/03_child_node_parameters.request.json new file mode 100644 index 0000000..13c721c --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/queries/03_child_node_parameters.request.json @@ -0,0 +1,122 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album", + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + }, + "MediaType": { + "type": "column", + "column": "MediaType", + "fields": { + "type": "object", + "fields": { + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "MediaTypeId": { + "type": "column", + "column": "MediaTypeId", + "fields": null + } + } + } + } + } + } + }, + "arguments": { + "limit": { + "type": "literal", + "value": 5 + } + } + } + } + } + } + } + } + }, + "arguments": { + "limit": { + "type": "literal", + "value": 20 + }, + "where": { + "type": "literal", + "value": { + "AlbumId": { + "_gt": 5 + } + } + }, + "_forwarded_headers": { + "type": "literal", + "value": { + "Authorization": "Bearer " + } + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/queries/04_foreach.request.json b/crates/ndc-graphql/tests/config-3/queries/04_foreach.request.json new file mode 100644 index 0000000..280bd24 --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/queries/04_foreach.request.json @@ -0,0 +1,125 @@ +{ + "$schema": "_query_request.schema.json", + "collection": "Album_by_pk", + "variables": [ + { + "AlbumId": 1, + "TracksWhere": { + "TrackId": { + "_gte": 1 + } + }, + "headers": { + "Authorization": "Bearer " + } + }, + { + "AlbumId": 2, + "TracksWhere": { + "TrackId": { + "_gte": 2 + } + }, + "headers": { + "Authorization": "Bearer " + } + }, + { + "AlbumId": 3, + "TracksWhere": { + "TrackId": { + "_gte": 3 + } + }, + "headers": { + "Authorization": "Bearer " + } + } + ], + "query": { + "fields": { + "__value": { + "type": "column", + "column": "__value", + "fields": { + "type": "object", + "fields": { + "AlbumId": { + "type": "column", + "column": "AlbumId", + "fields": null + }, + "Title": { + "type": "column", + "column": "Title", + "fields": null + }, + "Artist": { + "type": "column", + "column": "Artist", + "fields": { + "type": "object", + "fields": { + "ArtistId": { + "type": "column", + "column": "ArtistId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + } + } + } + }, + "Tracks": { + "type": "column", + "column": "Tracks", + "fields": { + "type": "array", + "fields": { + "type": "object", + "fields": { + "TrackId": { + "type": "column", + "column": "TrackId", + "fields": null + }, + "Name": { + "type": "column", + "column": "Name", + "fields": null + }, + "UnitPrice": { + "type": "column", + "column": "UnitPrice", + "fields": null + } + } + } + }, + "arguments": { + "where": { + "type": "variable", + "name": "TracksWhere" + } + } + } + } + } + } + } + }, + "arguments": { + "AlbumId": { + "type": "variable", + "name": "AlbumId" + }, + "_forwarded_headers": { + "type": "variable", + "name": "headers" + } + }, + "collection_relationships": {} +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/config-3/queries/_query_request.schema.json b/crates/ndc-graphql/tests/config-3/queries/_query_request.schema.json new file mode 100644 index 0000000..6f13801 --- /dev/null +++ b/crates/ndc-graphql/tests/config-3/queries/_query_request.schema.json @@ -0,0 +1,974 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Query Request", + "description": "This is the request body of the query POST endpoint", + "type": "object", + "required": [ + "arguments", + "collection", + "collection_relationships", + "query" + ], + "properties": { + "collection": { + "description": "The name of a collection", + "type": "string" + }, + "query": { + "description": "The query syntax tree", + "allOf": [ + { + "$ref": "#/definitions/Query" + } + ] + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Argument" + } + }, + "collection_relationships": { + "description": "Any relationships between collections involved in the query request", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Relationship" + } + }, + "variables": { + "description": "One set of named variables for each rowset to fetch. Each variable set should be subtituted in turn, and a fresh set of rows returned.", + "type": [ + "array", + "null" + ], + "items": { + "type": "object", + "additionalProperties": true + } + } + }, + "definitions": { + "Query": { + "title": "Query", + "type": "object", + "properties": { + "aggregates": { + "description": "Aggregate fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Aggregate" + } + }, + "fields": { + "description": "Fields of the query", + "type": [ + "object", + "null" + ], + "additionalProperties": { + "$ref": "#/definitions/Field" + } + }, + "limit": { + "description": "Optionally limit to N results", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "offset": { + "description": "Optionally offset from the Nth result", + "type": [ + "integer", + "null" + ], + "format": "uint32", + "minimum": 0.0 + }, + "order_by": { + "anyOf": [ + { + "$ref": "#/definitions/OrderBy" + }, + { + "type": "null" + } + ] + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "Aggregate": { + "title": "Aggregate", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "distinct", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column_count" + ] + }, + "column": { + "description": "The column to apply the count aggregate function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "distinct": { + "description": "Whether or not only distinct items should be counted", + "type": "boolean" + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count" + ] + } + } + } + ] + }, + "Field": { + "title": "Field", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "type": "string" + }, + "fields": { + "description": "When the type of the column is a (possibly-nullable) array or object, the caller can request a subset of the complete column data, by specifying fields to fetch here. If omitted, the column data will be fetched in full.", + "anyOf": [ + { + "$ref": "#/definitions/NestedField" + }, + { + "type": "null" + } + ] + }, + "arguments": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Argument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "query", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "relationship" + ] + }, + "query": { + "$ref": "#/definitions/Query" + }, + "relationship": { + "description": "The name of the relationship to follow for the subquery", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "NestedField": { + "title": "NestedField", + "oneOf": [ + { + "title": "NestedObject", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "object" + ] + }, + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/Field" + } + } + } + }, + { + "title": "NestedArray", + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "array" + ] + }, + "fields": { + "$ref": "#/definitions/NestedField" + } + } + } + ] + }, + "Argument": { + "title": "Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + } + ] + }, + "RelationshipArgument": { + "title": "Relationship Argument", + "oneOf": [ + { + "description": "The argument is provided by reference to a variable", + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "description": "The argument is provided as a literal value", + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "literal" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "OrderBy": { + "title": "Order By", + "type": "object", + "required": [ + "elements" + ], + "properties": { + "elements": { + "description": "The elements to order by, in priority order", + "type": "array", + "items": { + "$ref": "#/definitions/OrderByElement" + } + } + } + }, + "OrderByElement": { + "title": "Order By Element", + "type": "object", + "required": [ + "order_direction", + "target" + ], + "properties": { + "order_direction": { + "$ref": "#/definitions/OrderDirection" + }, + "target": { + "$ref": "#/definitions/OrderByTarget" + } + } + }, + "OrderDirection": { + "title": "Order Direction", + "type": "string", + "enum": [ + "asc", + "desc" + ] + }, + "OrderByTarget": { + "title": "Order By Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "column", + "function", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "single_column_aggregate" + ] + }, + "column": { + "description": "The column to apply the aggregation function to", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "function": { + "description": "Single column aggregate function name.", + "type": "string" + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "star_count_aggregate" + ] + }, + "path": { + "description": "Non-empty collection of relationships to traverse", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + } + ] + }, + "PathElement": { + "title": "Path Element", + "type": "object", + "required": [ + "arguments", + "relationship" + ], + "properties": { + "relationship": { + "description": "The name of the relationship to follow", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + }, + "predicate": { + "description": "A predicate expression to apply to the target collection", + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + }, + "Expression": { + "title": "Expression", + "oneOf": [ + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "and" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expressions", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "or" + ] + }, + "expressions": { + "type": "array", + "items": { + "$ref": "#/definitions/Expression" + } + } + } + }, + { + "type": "object", + "required": [ + "expression", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "not" + ] + }, + "expression": { + "$ref": "#/definitions/Expression" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "$ref": "#/definitions/UnaryComparisonOperator" + } + } + }, + { + "type": "object", + "required": [ + "column", + "operator", + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "binary_comparison_operator" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + }, + "operator": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/ComparisonValue" + } + } + }, + { + "type": "object", + "required": [ + "in_collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "exists" + ] + }, + "in_collection": { + "$ref": "#/definitions/ExistsInCollection" + }, + "predicate": { + "anyOf": [ + { + "$ref": "#/definitions/Expression" + }, + { + "type": "null" + } + ] + } + } + } + ] + }, + "ComparisonTarget": { + "title": "Comparison Target", + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "path", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + }, + "path": { + "description": "Any relationships to traverse to reach this column", + "type": "array", + "items": { + "$ref": "#/definitions/PathElement" + } + } + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "root_collection_column" + ] + }, + "name": { + "description": "The name of the column", + "type": "string" + }, + "field_path": { + "description": "Path to a nested field within an object column", + "type": [ + "array", + "null" + ], + "items": { + "type": "string" + } + } + } + } + ] + }, + "UnaryComparisonOperator": { + "title": "Unary Comparison Operator", + "type": "string", + "enum": [ + "is_null" + ] + }, + "ComparisonValue": { + "title": "Comparison Value", + "oneOf": [ + { + "type": "object", + "required": [ + "column", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "column" + ] + }, + "column": { + "$ref": "#/definitions/ComparisonTarget" + } + } + }, + { + "type": "object", + "required": [ + "type", + "value" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "scalar" + ] + }, + "value": true + } + }, + { + "type": "object", + "required": [ + "name", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "variable" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "ExistsInCollection": { + "title": "Exists In Collection", + "oneOf": [ + { + "type": "object", + "required": [ + "arguments", + "relationship", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "related" + ] + }, + "relationship": { + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + { + "type": "object", + "required": [ + "arguments", + "collection", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "unrelated" + ] + }, + "collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + } + ] + }, + "Relationship": { + "title": "Relationship", + "type": "object", + "required": [ + "arguments", + "column_mapping", + "relationship_type", + "target_collection" + ], + "properties": { + "column_mapping": { + "description": "A mapping between columns on the source collection to columns on the target collection", + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "relationship_type": { + "$ref": "#/definitions/RelationshipType" + }, + "target_collection": { + "description": "The name of a collection", + "type": "string" + }, + "arguments": { + "description": "Values to be provided to any collection arguments", + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/RelationshipArgument" + } + } + } + }, + "RelationshipType": { + "title": "Relationship Type", + "type": "string", + "enum": [ + "object", + "array" + ] + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql/tests/query_builder.rs b/crates/ndc-graphql/tests/query_builder.rs new file mode 100644 index 0000000..8dffaf0 --- /dev/null +++ b/crates/ndc-graphql/tests/query_builder.rs @@ -0,0 +1,109 @@ +use common::config::ServerConfig; +use common::config_file::ServerConfigFile; +use insta::{assert_json_snapshot, assert_snapshot, assert_yaml_snapshot, glob}; +use ndc_graphql::{ + connector::{ + capabilities::capabilities, schema::schema_response, setup::GraphQLConnectorSetup, + }, + query_builder::{build_mutation_document, build_query_document}, +}; +use ndc_sdk::models; +use schemars::schema_for; +use std::{collections::HashMap, fs, path::PathBuf}; + +#[tokio::test] +#[ignore] +async fn update_json_schema() { + for config in ["config-1", "config-2", "config-3"] { + fs::write( + format!("./tests/{config}/queries/_query_request.schema.json"), + serde_json::to_string_pretty(&schema_for!(models::QueryRequest)) + .expect("Should serialize schema to json"), + ) + .expect("Should be able to write out schema file"); + fs::write( + format!("./tests/{config}/mutations/_mutation_request.schema.json"), + serde_json::to_string_pretty(&schema_for!(models::MutationRequest)) + .expect("Should serialize schema to json"), + ) + .expect("Should be able to write out schema file"); + fs::write( + format!("./tests/{config}/configuration/configuration.schema.json"), + serde_json::to_string_pretty(&schema_for!(ServerConfigFile)) + .expect("Should serialize schema to json"), + ) + .expect("Should be able to write out schema file"); + } +} + +async fn read_configuration(config: &str) -> ServerConfig { + let configuration_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("tests") + .join(config) + .join("configuration"); + let env = HashMap::from_iter(vec![ + ("GRAPHQL_ENDPOINT".to_owned(), "".to_owned()), + ("GRAPHQL_ENDPOINT_SECRET".to_owned(), "".to_owned()), + ]); + GraphQLConnectorSetup::new(env) + .read_configuration(configuration_dir) + .await + .expect("Should sucessfully read configuration") +} + +// We use insta for snapshot testing +// Install it with `cargo install cargo-insta` +// The usual workflow is to run `cargo insta test`, then `cargo insta review` +// For more info, see insta docs: https://insta.rs/ + +#[tokio::test] +async fn test_build_graphql_query() { + for config in ["config-1", "config-2", "config-3"] { + let configuration = read_configuration(config).await; + + glob!(format!("./{config}/queries"), "*.request.json", |path| { + let request = fs::read_to_string(path).expect("Should be able to read file"); + let request: models::QueryRequest = + serde_json::from_str(&request).expect("Should be valid request json"); + let operation = build_query_document(&request, &configuration) + .expect("Should sucessfully build query document"); + + assert_snapshot!("Query String", operation.query); + assert_json_snapshot!("Variables", operation.variables); + assert_yaml_snapshot!("Headers", operation.headers); + }); + } +} + +#[tokio::test] +async fn test_build_graphql_mutation() { + for config in ["config-1", "config-2", "config-3"] { + let configuration = read_configuration(config).await; + + glob!(format!("./{config}/mutations"), "*.request.json", |path| { + let request = fs::read_to_string(path).expect("Should be able to read file"); + let request: models::MutationRequest = + serde_json::from_str(&request).expect("Should be valid request json"); + let operation = build_mutation_document(&request, &configuration) + .expect("Should sucessfully build query document"); + + assert_snapshot!("Query String", operation.query); + assert_json_snapshot!("Variables", operation.variables); + assert_yaml_snapshot!("Headers", operation.headers); + }); + } +} + +#[tokio::test] +async fn test_generated_schema() { + for config in ["config-1", "config-2", "config-3"] { + let configuration = read_configuration(config).await; + let schema = schema_response(&configuration); + assert_yaml_snapshot!(format!("{config} NDC Schema"), schema); + } +} + +#[test] +fn test_capabilities() { + assert_yaml_snapshot!("Capabilities", capabilities()) +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Capabilities.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Capabilities.snap new file mode 100644 index 0000000..26ec2b4 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Capabilities.snap @@ -0,0 +1,12 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: capabilities() +--- +version: 0.1.4 +capabilities: + query: + variables: {} + explain: {} + nested_fields: {} + mutation: + explain: {} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Headers@01_basic_query.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@01_basic_query.request.json.snap new file mode 100644 index 0000000..4c3a242 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@01_basic_query.request.json.snap @@ -0,0 +1,6 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.headers +input_file: crates/ndc-graphql/tests/config-3/queries/01_basic_query.request.json +--- +Authorization: Bearer diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Headers@01_single_operation.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@01_single_operation.request.json.snap new file mode 100644 index 0000000..1e4aa4b --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@01_single_operation.request.json.snap @@ -0,0 +1,6 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.headers +input_file: crates/ndc-graphql/tests/config-3/mutations/01_single_operation.request.json +--- +Authorization: Bearer diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Headers@02_multiple_operations.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@02_multiple_operations.request.json.snap new file mode 100644 index 0000000..7c3e6fc --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@02_multiple_operations.request.json.snap @@ -0,0 +1,6 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.headers +input_file: crates/ndc-graphql/tests/config-3/mutations/02_multiple_operations.request.json +--- +Authorization: Bearer diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Headers@02_root_node_parameters.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@02_root_node_parameters.request.json.snap new file mode 100644 index 0000000..d722594 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@02_root_node_parameters.request.json.snap @@ -0,0 +1,6 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.headers +input_file: crates/ndc-graphql/tests/config-3/queries/02_root_node_parameters.request.json +--- +Authorization: Bearer diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Headers@03_child_node_parameters.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@03_child_node_parameters.request.json.snap new file mode 100644 index 0000000..45a53d8 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@03_child_node_parameters.request.json.snap @@ -0,0 +1,6 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.headers +input_file: crates/ndc-graphql/tests/config-3/queries/03_child_node_parameters.request.json +--- +Authorization: Bearer diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Headers@04_foreach.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@04_foreach.request.json.snap new file mode 100644 index 0000000..c777c1a --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Headers@04_foreach.request.json.snap @@ -0,0 +1,6 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.headers +input_file: crates/ndc-graphql/tests/config-3/queries/04_foreach.request.json +--- +Authorization: Bearer diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Query String@01_basic_query.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@01_basic_query.request.json.snap new file mode 100644 index 0000000..ec2697e --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@01_basic_query.request.json.snap @@ -0,0 +1,24 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.query +input_file: crates/ndc-graphql/tests/config-3/queries/01_basic_query.request.json +--- +query { + __value: Album { + AlbumId + Title + Artist { + ArtistId + Name + } + Tracks { + TrackId + Name + UnitPrice + MediaType { + Name + MediaTypeId + } + } + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Query String@01_single_operation.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@01_single_operation.request.json.snap new file mode 100644 index 0000000..608d8b7 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@01_single_operation.request.json.snap @@ -0,0 +1,11 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.query +input_file: crates/ndc-graphql/tests/config-3/mutations/01_single_operation.request.json +--- +mutation($arg_1__set: Album_set_input, $arg_2_pk_columns: Album_pk_columns_input!) { + procedure_0: update_Album_by_pk(_set: $arg_1__set, pk_columns: $arg_2_pk_columns) { + AlbumId + Title + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Query String@02_multiple_operations.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@02_multiple_operations.request.json.snap new file mode 100644 index 0000000..b62f782 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@02_multiple_operations.request.json.snap @@ -0,0 +1,15 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.query +input_file: crates/ndc-graphql/tests/config-3/mutations/02_multiple_operations.request.json +--- +mutation($arg_1__set: Album_set_input, $arg_2_pk_columns: Album_pk_columns_input!, $arg_3__set: Album_set_input, $arg_4_pk_columns: Album_pk_columns_input!) { + procedure_0: update_Album_by_pk(_set: $arg_1__set, pk_columns: $arg_2_pk_columns) { + AlbumId + Title + } + procedure_1: update_Album_by_pk(_set: $arg_3__set, pk_columns: $arg_4_pk_columns) { + AlbumId + Title + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Query String@02_root_node_parameters.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@02_root_node_parameters.request.json.snap new file mode 100644 index 0000000..b8e78a5 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@02_root_node_parameters.request.json.snap @@ -0,0 +1,24 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.query +input_file: crates/ndc-graphql/tests/config-3/queries/02_root_node_parameters.request.json +--- +query($arg_1_limit: Int, $arg_2_where: Album_bool_exp) { + __value: Album(limit: $arg_1_limit, where: $arg_2_where) { + AlbumId + Title + Artist { + ArtistId + Name + } + Tracks { + TrackId + Name + UnitPrice + MediaType { + Name + MediaTypeId + } + } + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Query String@03_child_node_parameters.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@03_child_node_parameters.request.json.snap new file mode 100644 index 0000000..8e42b10 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@03_child_node_parameters.request.json.snap @@ -0,0 +1,24 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.query +input_file: crates/ndc-graphql/tests/config-3/queries/03_child_node_parameters.request.json +--- +query($arg_1_limit: Int, $arg_2_where: Album_bool_exp, $arg_3_limit: Int) { + __value: Album(limit: $arg_1_limit, where: $arg_2_where) { + AlbumId + Title + Artist { + ArtistId + Name + } + Tracks(limit: $arg_3_limit) { + TrackId + Name + UnitPrice + MediaType { + Name + MediaTypeId + } + } + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Query String@04_foreach.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@04_foreach.request.json.snap new file mode 100644 index 0000000..b0d3aed --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Query String@04_foreach.request.json.snap @@ -0,0 +1,46 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.query +input_file: crates/ndc-graphql/tests/config-3/queries/04_foreach.request.json +--- +query($q1_arg_1_AlbumId: Int!, $q1_arg_2_where: Track_bool_exp, $q2_arg_1_AlbumId: Int!, $q2_arg_2_where: Track_bool_exp, $q3_arg_1_AlbumId: Int!, $q3_arg_2_where: Track_bool_exp) { + q1__value: Album_by_pk(AlbumId: $q1_arg_1_AlbumId) { + AlbumId + Title + Artist { + ArtistId + Name + } + Tracks(where: $q1_arg_2_where) { + TrackId + Name + UnitPrice + } + } + q2__value: Album_by_pk(AlbumId: $q2_arg_1_AlbumId) { + AlbumId + Title + Artist { + ArtistId + Name + } + Tracks(where: $q2_arg_2_where) { + TrackId + Name + UnitPrice + } + } + q3__value: Album_by_pk(AlbumId: $q3_arg_1_AlbumId) { + AlbumId + Title + Artist { + ArtistId + Name + } + Tracks(where: $q3_arg_2_where) { + TrackId + Name + UnitPrice + } + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Variables@01_basic_query.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@01_basic_query.request.json.snap new file mode 100644 index 0000000..98ae060 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@01_basic_query.request.json.snap @@ -0,0 +1,6 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.variables +input_file: crates/ndc-graphql/tests/config-3/queries/01_basic_query.request.json +--- +{} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Variables@01_single_operation.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@01_single_operation.request.json.snap new file mode 100644 index 0000000..d60f181 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@01_single_operation.request.json.snap @@ -0,0 +1,13 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.variables +input_file: crates/ndc-graphql/tests/config-3/mutations/01_single_operation.request.json +--- +{ + "arg_1__set": { + "ArtistId": 1 + }, + "arg_2_pk_columns": { + "AlbumId": 1 + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Variables@02_multiple_operations.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@02_multiple_operations.request.json.snap new file mode 100644 index 0000000..82932ca --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@02_multiple_operations.request.json.snap @@ -0,0 +1,19 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.variables +input_file: crates/ndc-graphql/tests/config-3/mutations/02_multiple_operations.request.json +--- +{ + "arg_1__set": { + "ArtistId": 1 + }, + "arg_2_pk_columns": { + "AlbumId": 1 + }, + "arg_3__set": { + "ArtistId": 1 + }, + "arg_4_pk_columns": { + "AlbumId": 1 + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Variables@02_root_node_parameters.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@02_root_node_parameters.request.json.snap new file mode 100644 index 0000000..4f320d5 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@02_root_node_parameters.request.json.snap @@ -0,0 +1,13 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.variables +input_file: crates/ndc-graphql/tests/config-3/queries/02_root_node_parameters.request.json +--- +{ + "arg_1_limit": 20, + "arg_2_where": { + "AlbumId": { + "_gt": 5 + } + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Variables@03_child_node_parameters.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@03_child_node_parameters.request.json.snap new file mode 100644 index 0000000..0eb07ac --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@03_child_node_parameters.request.json.snap @@ -0,0 +1,14 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.variables +input_file: crates/ndc-graphql/tests/config-3/queries/03_child_node_parameters.request.json +--- +{ + "arg_1_limit": 20, + "arg_2_where": { + "AlbumId": { + "_gt": 5 + } + }, + "arg_3_limit": 5 +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__Variables@04_foreach.request.json.snap b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@04_foreach.request.json.snap new file mode 100644 index 0000000..8166584 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__Variables@04_foreach.request.json.snap @@ -0,0 +1,25 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: operation.variables +input_file: crates/ndc-graphql/tests/config-3/queries/04_foreach.request.json +--- +{ + "q1_arg_1_AlbumId": 1, + "q1_arg_2_where": { + "TrackId": { + "_gte": 1 + } + }, + "q2_arg_1_AlbumId": 2, + "q2_arg_2_where": { + "TrackId": { + "_gte": 2 + } + }, + "q3_arg_1_AlbumId": 3, + "q3_arg_2_where": { + "TrackId": { + "_gte": 3 + } + } +} diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__config-1 NDC Schema.snap b/crates/ndc-graphql/tests/snapshots/query_builder__config-1 NDC Schema.snap new file mode 100644 index 0000000..e437341 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__config-1 NDC Schema.snap @@ -0,0 +1,16235 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: schema +--- +scalar_types: + Album_constraint: + representation: + type: enum + one_of: + - PK_Album + aggregate_functions: {} + comparison_operators: {} + Album_select_column: + representation: + type: enum + one_of: + - AlbumId + - ArtistId + - Title + aggregate_functions: {} + comparison_operators: {} + Album_update_column: + representation: + type: enum + one_of: + - ArtistId + - Title + aggregate_functions: {} + comparison_operators: {} + Artist_constraint: + representation: + type: enum + one_of: + - PK_Artist + aggregate_functions: {} + comparison_operators: {} + Artist_select_column: + representation: + type: enum + one_of: + - ArtistId + - Name + aggregate_functions: {} + comparison_operators: {} + Artist_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + Boolean: + aggregate_functions: {} + comparison_operators: {} + Customer_constraint: + representation: + type: enum + one_of: + - PK_Customer + aggregate_functions: {} + comparison_operators: {} + Customer_select_column: + representation: + type: enum + one_of: + - Address + - City + - Company + - Country + - CustomerId + - Email + - Fax + - FirstName + - LastName + - Phone + - PostalCode + - State + - SupportRepId + aggregate_functions: {} + comparison_operators: {} + Customer_update_column: + representation: + type: enum + one_of: + - Address + - City + - Company + - Country + - Email + - Fax + - FirstName + - LastName + - Phone + - PostalCode + - State + - SupportRepId + aggregate_functions: {} + comparison_operators: {} + Employee_constraint: + representation: + type: enum + one_of: + - PK_Employee + aggregate_functions: {} + comparison_operators: {} + Employee_select_column: + representation: + type: enum + one_of: + - Address + - BirthDate + - City + - Country + - Email + - EmployeeId + - Fax + - FirstName + - HireDate + - LastName + - Phone + - PostalCode + - ReportsTo + - State + - Title + aggregate_functions: {} + comparison_operators: {} + Employee_update_column: + representation: + type: enum + one_of: + - Address + - BirthDate + - City + - Country + - Email + - Fax + - FirstName + - HireDate + - LastName + - Phone + - PostalCode + - ReportsTo + - State + - Title + aggregate_functions: {} + comparison_operators: {} + Float: + aggregate_functions: {} + comparison_operators: {} + Genre_constraint: + representation: + type: enum + one_of: + - PK_Genre + aggregate_functions: {} + comparison_operators: {} + Genre_select_column: + representation: + type: enum + one_of: + - GenreId + - Name + aggregate_functions: {} + comparison_operators: {} + Genre_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + Int: + aggregate_functions: {} + comparison_operators: {} + InvoiceLine_constraint: + representation: + type: enum + one_of: + - PK_InvoiceLine + aggregate_functions: {} + comparison_operators: {} + InvoiceLine_select_column: + representation: + type: enum + one_of: + - InvoiceId + - InvoiceLineId + - Quantity + - TrackId + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + InvoiceLine_update_column: + representation: + type: enum + one_of: + - InvoiceId + - Quantity + - TrackId + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + Invoice_constraint: + representation: + type: enum + one_of: + - PK_Invoice + aggregate_functions: {} + comparison_operators: {} + Invoice_select_column: + representation: + type: enum + one_of: + - BillingAddress + - BillingCity + - BillingCountry + - BillingPostalCode + - BillingState + - CustomerId + - InvoiceDate + - InvoiceId + - Total + aggregate_functions: {} + comparison_operators: {} + Invoice_update_column: + representation: + type: enum + one_of: + - BillingAddress + - BillingCity + - BillingCountry + - BillingPostalCode + - BillingState + - CustomerId + - InvoiceDate + - Total + aggregate_functions: {} + comparison_operators: {} + MediaType_constraint: + representation: + type: enum + one_of: + - PK_MediaType + aggregate_functions: {} + comparison_operators: {} + MediaType_select_column: + representation: + type: enum + one_of: + - MediaTypeId + - Name + aggregate_functions: {} + comparison_operators: {} + MediaType_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + PlaylistTrack_constraint: + representation: + type: enum + one_of: + - PK_PlaylistTrack + aggregate_functions: {} + comparison_operators: {} + PlaylistTrack_select_column: + representation: + type: enum + one_of: + - PlaylistId + - TrackId + aggregate_functions: {} + comparison_operators: {} + PlaylistTrack_update_column: + representation: + type: enum + one_of: + - PlaylistId + - TrackId + aggregate_functions: {} + comparison_operators: {} + Playlist_constraint: + representation: + type: enum + one_of: + - PK_Playlist + aggregate_functions: {} + comparison_operators: {} + Playlist_select_column: + representation: + type: enum + one_of: + - Name + - PlaylistId + aggregate_functions: {} + comparison_operators: {} + Playlist_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + String: + aggregate_functions: {} + comparison_operators: {} + Track_constraint: + representation: + type: enum + one_of: + - PK_Track + aggregate_functions: {} + comparison_operators: {} + Track_select_column: + representation: + type: enum + one_of: + - AlbumId + - Bytes + - Composer + - GenreId + - MediaTypeId + - Milliseconds + - Name + - TrackId + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + Track_update_column: + representation: + type: enum + one_of: + - AlbumId + - Bytes + - Composer + - GenreId + - MediaTypeId + - Milliseconds + - Name + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + cursor_ordering: + representation: + type: enum + one_of: + - ASC + - DESC + aggregate_functions: {} + comparison_operators: {} + numeric: + aggregate_functions: {} + comparison_operators: {} + order_by: + representation: + type: enum + one_of: + - asc + - asc_nulls_first + - asc_nulls_last + - desc + - desc_nulls_first + - desc_nulls_last + aggregate_functions: {} + comparison_operators: {} + timestamp: + aggregate_functions: {} + comparison_operators: {} +object_types: + Album: + description: "columns and relationships of \"Album\"" + fields: + AlbumId: + type: + type: named + name: Int + Artist: + description: An object relationship + type: + type: named + name: Artist + ArtistId: + type: + type: named + name: Int + Title: + type: + type: named + name: String + Tracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + description: An aggregate relationship + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Album_aggregate: + description: "aggregated selection of \"Album\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Album + Album_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_bool_exp_count + Album_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Album_aggregate_fields: + description: "aggregate fields of \"Album\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Album_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Album_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Album_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Album_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Album_variance_fields + Album_aggregate_order_by: + description: "order by aggregate values of table \"Album\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Album_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Album_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Album_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Album_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Album_variance_order_by + Album_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Album\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + Album_avg_fields: + description: aggregate avg on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_avg_order_by: + description: "order by avg() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_bool_exp: + description: "Boolean expression to filter rows from the table \"Album\". All fields are combined with a logical 'AND'." + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Artist: + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Title: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_bool_exp + Album_inc_input: + description: "input type for incrementing numeric columns in table \"Album\"" + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Album_insert_input: + description: "input type for inserting data into table \"Album\"" + fields: + Artist: + type: + type: nullable + underlying_type: + type: named + name: Artist_obj_rel_insert_input + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_arr_rel_insert_input + Album_max_fields: + description: aggregate max on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_max_order_by: + description: "order by max() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_min_fields: + description: aggregate min on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_min_order_by: + description: "order by min() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_mutation_response: + description: "response of any mutation on the table \"Album\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Album + Album_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Album\"" + fields: + data: + type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + Album_on_conflict: + description: "on_conflict condition type for table \"Album\"" + fields: + constraint: + type: + type: named + name: Album_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Album_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Album_order_by: + description: "Ordering options when selecting data from \"Album\"." + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Artist: + type: + type: nullable + underlying_type: + type: named + name: Artist_order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_order_by + Album_pk_columns_input: + description: "primary key columns input for table: Album" + fields: + AlbumId: + type: + type: named + name: Int + Album_set_input: + description: "input type for updating data in table \"Album\"" + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_stddev_fields: + description: aggregate stddev on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_stddev_order_by: + description: "order by stddev() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_stream_cursor_input: + description: "Streaming cursor of the table \"Album\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Album_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Album_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_sum_fields: + description: aggregate sum on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Album_sum_order_by: + description: "order by sum() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Album_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Album_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Album_bool_exp + Album_var_pop_fields: + description: aggregate var_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_var_pop_order_by: + description: "order by var_pop() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_var_samp_fields: + description: aggregate var_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_var_samp_order_by: + description: "order by var_samp() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_variance_fields: + description: aggregate variance on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_variance_order_by: + description: "order by variance() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Artist: + description: "columns and relationships of \"Artist\"" + fields: + Albums: + description: An array relationship + type: + type: array + element_type: + type: named + name: Album + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Albums_aggregate: + description: An aggregate relationship + type: + type: named + name: Album_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + ArtistId: + type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_aggregate: + description: "aggregated selection of \"Artist\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Artist_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Artist + Artist_aggregate_fields: + description: "aggregate fields of \"Artist\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Artist_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Artist_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Artist_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Artist_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Artist_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Artist_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Artist_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Artist_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Artist_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Artist_variance_fields + Artist_avg_fields: + description: aggregate avg on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_bool_exp: + description: "Boolean expression to filter rows from the table \"Artist\". All fields are combined with a logical 'AND'." + fields: + Albums: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Albums_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_bool_exp + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_bool_exp + Artist_insert_input: + description: "input type for inserting data into table \"Artist\"" + fields: + Albums: + type: + type: nullable + underlying_type: + type: named + name: Album_arr_rel_insert_input + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_max_fields: + description: aggregate max on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_min_fields: + description: aggregate min on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_mutation_response: + description: "response of any mutation on the table \"Artist\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Artist + Artist_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Artist\"" + fields: + data: + type: + type: named + name: Artist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Artist_on_conflict + Artist_on_conflict: + description: "on_conflict condition type for table \"Artist\"" + fields: + constraint: + type: + type: named + name: Artist_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Artist_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Artist_order_by: + description: "Ordering options when selecting data from \"Artist\"." + fields: + Albums_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + Artist_pk_columns_input: + description: "primary key columns input for table: Artist" + fields: + ArtistId: + type: + type: named + name: Int + Artist_set_input: + description: "input type for updating data in table \"Artist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_stddev_fields: + description: aggregate stddev on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_stream_cursor_input: + description: "Streaming cursor of the table \"Artist\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Artist_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Artist_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_sum_fields: + description: aggregate sum on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Artist_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Artist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Artist_bool_exp + Artist_var_pop_fields: + description: aggregate var_pop on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_var_samp_fields: + description: aggregate var_samp on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_variance_fields: + description: aggregate variance on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer: + description: "columns and relationships of \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: named + name: Int + Email: + type: + type: named + name: String + Employee: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Employee + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: named + name: String + Invoices: + description: An array relationship + type: + type: array + element_type: + type: named + name: Invoice + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoices_aggregate: + description: An aggregate relationship + type: + type: named + name: Invoice_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + LastName: + type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_aggregate: + description: "aggregated selection of \"Customer\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Customer + Customer_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_bool_exp_count + Customer_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Customer_aggregate_fields: + description: "aggregate fields of \"Customer\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Customer_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Customer_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Customer_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Customer_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Customer_variance_fields + Customer_aggregate_order_by: + description: "order by aggregate values of table \"Customer\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Customer_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Customer_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Customer_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Customer_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Customer_variance_order_by + Customer_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Customer\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + Customer_avg_fields: + description: aggregate avg on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_avg_order_by: + description: "order by avg() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_bool_exp: + description: "Boolean expression to filter rows from the table \"Customer\". All fields are combined with a logical 'AND'." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + City: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Company: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Country: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Email: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Fax: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Invoices: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoices_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_bool_exp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Phone: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + State: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_bool_exp + Customer_inc_input: + description: "input type for incrementing numeric columns in table \"Customer\"" + fields: + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_insert_input: + description: "input type for inserting data into table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_obj_rel_insert_input + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + Invoices: + type: + type: nullable + underlying_type: + type: named + name: Invoice_arr_rel_insert_input + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_max_fields: + description: aggregate max on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_max_order_by: + description: "order by max() on columns of table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Company: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_min_fields: + description: aggregate min on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_min_order_by: + description: "order by min() on columns of table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Company: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_mutation_response: + description: "response of any mutation on the table \"Customer\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Customer + Customer_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Customer\"" + fields: + data: + type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + Customer_on_conflict: + description: "on_conflict condition type for table \"Customer\"" + fields: + constraint: + type: + type: named + name: Customer_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Customer_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customer_order_by: + description: "Ordering options when selecting data from \"Customer\"." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Company: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoices_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_pk_columns_input: + description: "primary key columns input for table: Customer" + fields: + CustomerId: + type: + type: named + name: Int + Customer_set_input: + description: "input type for updating data in table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_stddev_fields: + description: aggregate stddev on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_stddev_order_by: + description: "order by stddev() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_stream_cursor_input: + description: "Streaming cursor of the table \"Customer\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Customer_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Customer_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_sum_fields: + description: aggregate sum on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_sum_order_by: + description: "order by sum() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Customer_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Customer_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Customer_bool_exp + Customer_var_pop_fields: + description: aggregate var_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_var_pop_order_by: + description: "order by var_pop() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_var_samp_fields: + description: aggregate var_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_var_samp_order_by: + description: "order by var_samp() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_variance_fields: + description: aggregate variance on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_variance_order_by: + description: "order by variance() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee: + description: "columns and relationships of \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Customers: + description: An array relationship + type: + type: array + element_type: + type: named + name: Customer + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customers_aggregate: + description: An aggregate relationship + type: + type: named + name: Customer_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Employee: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Employee + EmployeeId: + type: + type: named + name: Int + Employees: + description: An array relationship + type: + type: array + element_type: + type: named + name: Employee + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employees_aggregate: + description: An aggregate relationship + type: + type: named + name: Employee_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_aggregate: + description: "aggregated selection of \"Employee\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Employee + Employee_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_bool_exp_count + Employee_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Employee_aggregate_fields: + description: "aggregate fields of \"Employee\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Employee_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Employee_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Employee_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Employee_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Employee_variance_fields + Employee_aggregate_order_by: + description: "order by aggregate values of table \"Employee\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Employee_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Employee_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Employee_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Employee_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Employee_variance_order_by + Employee_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Employee\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + Employee_avg_fields: + description: aggregate avg on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_avg_order_by: + description: "order by avg() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_bool_exp: + description: "Boolean expression to filter rows from the table \"Employee\". All fields are combined with a logical 'AND'." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp_comparison_exp + City: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Country: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Customers: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customers_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_bool_exp + Email: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Employees: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employees_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_bool_exp + Fax: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp_comparison_exp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Phone: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + State: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Title: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_bool_exp + Employee_inc_input: + description: "input type for incrementing numeric columns in table \"Employee\"" + fields: + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + Employee_insert_input: + description: "input type for inserting data into table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Customers: + type: + type: nullable + underlying_type: + type: named + name: Customer_arr_rel_insert_input + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_obj_rel_insert_input + Employees: + type: + type: nullable + underlying_type: + type: named + name: Employee_arr_rel_insert_input + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_max_fields: + description: aggregate max on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_max_order_by: + description: "order by max() on columns of table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + HireDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_min_fields: + description: aggregate min on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_min_order_by: + description: "order by min() on columns of table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + HireDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_mutation_response: + description: "response of any mutation on the table \"Employee\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Employee + Employee_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Employee\"" + fields: + data: + type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + Employee_on_conflict: + description: "on_conflict condition type for table \"Employee\"" + fields: + constraint: + type: + type: named + name: Employee_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Employee_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employee_order_by: + description: "Ordering options when selecting data from \"Employee\"." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customers_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_order_by + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employees_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + HireDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_pk_columns_input: + description: "primary key columns input for table: Employee" + fields: + EmployeeId: + type: + type: named + name: Int + Employee_set_input: + description: "input type for updating data in table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_stddev_fields: + description: aggregate stddev on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_stddev_order_by: + description: "order by stddev() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_stream_cursor_input: + description: "Streaming cursor of the table \"Employee\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Employee_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Employee_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_sum_fields: + description: aggregate sum on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + Employee_sum_order_by: + description: "order by sum() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Employee_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Employee_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Employee_bool_exp + Employee_var_pop_fields: + description: aggregate var_pop on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_var_pop_order_by: + description: "order by var_pop() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_var_samp_fields: + description: aggregate var_samp on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_var_samp_order_by: + description: "order by var_samp() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_variance_fields: + description: aggregate variance on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_variance_order_by: + description: "order by variance() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Genre: + description: "columns and relationships of \"Genre\"" + fields: + GenreId: + type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + description: An aggregate relationship + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Genre_aggregate: + description: "aggregated selection of \"Genre\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Genre_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Genre + Genre_aggregate_fields: + description: "aggregate fields of \"Genre\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Genre_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Genre_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Genre_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Genre_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Genre_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Genre_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Genre_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Genre_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Genre_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Genre_variance_fields + Genre_avg_fields: + description: aggregate avg on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_bool_exp: + description: "Boolean expression to filter rows from the table \"Genre\". All fields are combined with a logical 'AND'." + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_bool_exp + Genre_insert_input: + description: "input type for inserting data into table \"Genre\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_arr_rel_insert_input + Genre_max_fields: + description: aggregate max on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_min_fields: + description: aggregate min on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_mutation_response: + description: "response of any mutation on the table \"Genre\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Genre + Genre_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Genre\"" + fields: + data: + type: + type: named + name: Genre_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Genre_on_conflict + Genre_on_conflict: + description: "on_conflict condition type for table \"Genre\"" + fields: + constraint: + type: + type: named + name: Genre_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Genre_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Genre_order_by: + description: "Ordering options when selecting data from \"Genre\"." + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_order_by + Genre_pk_columns_input: + description: "primary key columns input for table: Genre" + fields: + GenreId: + type: + type: named + name: Int + Genre_set_input: + description: "input type for updating data in table \"Genre\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_stddev_fields: + description: aggregate stddev on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_stream_cursor_input: + description: "Streaming cursor of the table \"Genre\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Genre_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Genre_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_sum_fields: + description: aggregate sum on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Genre_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Genre_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Genre_bool_exp + Genre_var_pop_fields: + description: aggregate var_pop on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_var_samp_fields: + description: aggregate var_samp on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_variance_fields: + description: aggregate variance on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Int_comparison_exp: + description: "Boolean expression to compare columns of type \"Int\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: Int + _gt: + type: + type: nullable + underlying_type: + type: named + name: Int + _gte: + type: + type: nullable + underlying_type: + type: named + name: Int + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Int + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _lt: + type: + type: nullable + underlying_type: + type: named + name: Int + _lte: + type: + type: nullable + underlying_type: + type: named + name: Int + _neq: + type: + type: nullable + underlying_type: + type: named + name: Int + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Int + Invoice: + description: "columns and relationships of \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + Customer: + description: An object relationship + type: + type: named + name: Customer + CustomerId: + type: + type: named + name: Int + InvoiceDate: + type: + type: named + name: timestamp + InvoiceId: + type: + type: named + name: Int + InvoiceLines: + description: An array relationship + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + description: An aggregate relationship + type: + type: named + name: InvoiceLine_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + Total: + type: + type: named + name: numeric + InvoiceLine: + description: "columns and relationships of \"InvoiceLine\"" + fields: + Invoice: + description: An object relationship + type: + type: named + name: Invoice + InvoiceId: + type: + type: named + name: Int + InvoiceLineId: + type: + type: named + name: Int + Quantity: + type: + type: named + name: Int + Track: + description: An object relationship + type: + type: named + name: Track + TrackId: + type: + type: named + name: Int + UnitPrice: + type: + type: named + name: numeric + InvoiceLine_aggregate: + description: "aggregated selection of \"InvoiceLine\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: InvoiceLine + InvoiceLine_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_bool_exp_count + InvoiceLine_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + InvoiceLine_aggregate_fields: + description: "aggregate fields of \"InvoiceLine\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_variance_fields + InvoiceLine_aggregate_order_by: + description: "order by aggregate values of table \"InvoiceLine\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_variance_order_by + InvoiceLine_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"InvoiceLine\"" + fields: + data: + type: + type: array + element_type: + type: named + name: InvoiceLine_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_on_conflict + InvoiceLine_avg_fields: + description: aggregate avg on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_avg_order_by: + description: "order by avg() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_bool_exp: + description: "Boolean expression to filter rows from the table \"InvoiceLine\". All fields are combined with a logical 'AND'." + fields: + Invoice: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_inc_input: + description: "input type for incrementing numeric columns in table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_insert_input: + description: "input type for inserting data into table \"InvoiceLine\"" + fields: + Invoice: + type: + type: nullable + underlying_type: + type: named + name: Invoice_obj_rel_insert_input + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_obj_rel_insert_input + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_max_fields: + description: aggregate max on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_max_order_by: + description: "order by max() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_min_fields: + description: aggregate min on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_min_order_by: + description: "order by min() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_mutation_response: + description: "response of any mutation on the table \"InvoiceLine\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: InvoiceLine + InvoiceLine_on_conflict: + description: "on_conflict condition type for table \"InvoiceLine\"" + fields: + constraint: + type: + type: named + name: InvoiceLine_constraint + update_columns: + type: + type: array + element_type: + type: named + name: InvoiceLine_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_order_by: + description: "Ordering options when selecting data from \"InvoiceLine\"." + fields: + Invoice: + type: + type: nullable + underlying_type: + type: named + name: Invoice_order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_pk_columns_input: + description: "primary key columns input for table: InvoiceLine" + fields: + InvoiceLineId: + type: + type: named + name: Int + InvoiceLine_set_input: + description: "input type for updating data in table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_stddev_fields: + description: aggregate stddev on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_stddev_order_by: + description: "order by stddev() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_stream_cursor_input: + description: "Streaming cursor of the table \"InvoiceLine\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: InvoiceLine_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + InvoiceLine_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_sum_fields: + description: aggregate sum on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_sum_order_by: + description: "order by sum() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_var_pop_fields: + description: aggregate var_pop on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_var_pop_order_by: + description: "order by var_pop() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_var_samp_fields: + description: aggregate var_samp on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_var_samp_order_by: + description: "order by var_samp() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_variance_fields: + description: aggregate variance on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_variance_order_by: + description: "order by variance() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_aggregate: + description: "aggregated selection of \"Invoice\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Invoice + Invoice_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_bool_exp_count + Invoice_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Invoice_aggregate_fields: + description: "aggregate fields of \"Invoice\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Invoice_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Invoice_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Invoice_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Invoice_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Invoice_variance_fields + Invoice_aggregate_order_by: + description: "order by aggregate values of table \"Invoice\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Invoice_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Invoice_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Invoice_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Invoice_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Invoice_variance_order_by + Invoice_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Invoice\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + Invoice_avg_fields: + description: aggregate avg on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_avg_order_by: + description: "order by avg() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_bool_exp: + description: "Boolean expression to filter rows from the table \"Invoice\". All fields are combined with a logical 'AND'." + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Customer: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp_comparison_exp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_bool_exp + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_bool_exp + Invoice_inc_input: + description: "input type for incrementing numeric columns in table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_insert_input: + description: "input type for inserting data into table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + Customer: + type: + type: nullable + underlying_type: + type: named + name: Customer_obj_rel_insert_input + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_arr_rel_insert_input + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_max_fields: + description: aggregate max on columns + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_max_order_by: + description: "order by max() on columns of table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingState: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_min_fields: + description: aggregate min on columns + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_min_order_by: + description: "order by min() on columns of table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingState: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_mutation_response: + description: "response of any mutation on the table \"Invoice\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Invoice + Invoice_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Invoice\"" + fields: + data: + type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + Invoice_on_conflict: + description: "on_conflict condition type for table \"Invoice\"" + fields: + constraint: + type: + type: named + name: Invoice_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Invoice_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoice_order_by: + description: "Ordering options when selecting data from \"Invoice\"." + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingState: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer: + type: + type: nullable + underlying_type: + type: named + name: Customer_order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_pk_columns_input: + description: "primary key columns input for table: Invoice" + fields: + InvoiceId: + type: + type: named + name: Int + Invoice_set_input: + description: "input type for updating data in table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_stddev_fields: + description: aggregate stddev on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_stddev_order_by: + description: "order by stddev() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_stream_cursor_input: + description: "Streaming cursor of the table \"Invoice\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Invoice_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Invoice_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_sum_fields: + description: aggregate sum on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_sum_order_by: + description: "order by sum() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Invoice_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Invoice_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Invoice_bool_exp + Invoice_var_pop_fields: + description: aggregate var_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_var_pop_order_by: + description: "order by var_pop() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_var_samp_fields: + description: aggregate var_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_var_samp_order_by: + description: "order by var_samp() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_variance_fields: + description: aggregate variance on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_variance_order_by: + description: "order by variance() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaType: + description: "columns and relationships of \"MediaType\"" + fields: + MediaTypeId: + type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + description: An aggregate relationship + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + MediaType_aggregate: + description: "aggregated selection of \"MediaType\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: MediaType_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: MediaType + MediaType_aggregate_fields: + description: "aggregate fields of \"MediaType\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: MediaType_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: MediaType_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: MediaType_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: MediaType_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: MediaType_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: MediaType_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: MediaType_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: MediaType_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: MediaType_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: MediaType_variance_fields + MediaType_avg_fields: + description: aggregate avg on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_bool_exp: + description: "Boolean expression to filter rows from the table \"MediaType\". All fields are combined with a logical 'AND'." + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_bool_exp + MediaType_insert_input: + description: "input type for inserting data into table \"MediaType\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_arr_rel_insert_input + MediaType_max_fields: + description: aggregate max on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_min_fields: + description: aggregate min on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_mutation_response: + description: "response of any mutation on the table \"MediaType\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: MediaType + MediaType_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"MediaType\"" + fields: + data: + type: + type: named + name: MediaType_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: MediaType_on_conflict + MediaType_on_conflict: + description: "on_conflict condition type for table \"MediaType\"" + fields: + constraint: + type: + type: named + name: MediaType_constraint + update_columns: + type: + type: array + element_type: + type: named + name: MediaType_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaType_order_by: + description: "Ordering options when selecting data from \"MediaType\"." + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_order_by + MediaType_pk_columns_input: + description: "primary key columns input for table: MediaType" + fields: + MediaTypeId: + type: + type: named + name: Int + MediaType_set_input: + description: "input type for updating data in table \"MediaType\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_stddev_fields: + description: aggregate stddev on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_stream_cursor_input: + description: "Streaming cursor of the table \"MediaType\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: MediaType_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + MediaType_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_sum_fields: + description: aggregate sum on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaType_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: MediaType_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: MediaType_bool_exp + MediaType_var_pop_fields: + description: aggregate var_pop on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_var_samp_fields: + description: aggregate var_samp on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_variance_fields: + description: aggregate variance on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist: + description: "columns and relationships of \"Playlist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: named + name: Int + PlaylistTracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + description: An aggregate relationship + type: + type: named + name: PlaylistTrack_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack: + description: "columns and relationships of \"PlaylistTrack\"" + fields: + Playlist: + description: An object relationship + type: + type: named + name: Playlist + PlaylistId: + type: + type: named + name: Int + Track: + description: An object relationship + type: + type: named + name: Track + TrackId: + type: + type: named + name: Int + PlaylistTrack_aggregate: + description: "aggregated selection of \"PlaylistTrack\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: PlaylistTrack + PlaylistTrack_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_bool_exp_count + PlaylistTrack_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + PlaylistTrack_aggregate_fields: + description: "aggregate fields of \"PlaylistTrack\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_variance_fields + PlaylistTrack_aggregate_order_by: + description: "order by aggregate values of table \"PlaylistTrack\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_variance_order_by + PlaylistTrack_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"PlaylistTrack\"" + fields: + data: + type: + type: array + element_type: + type: named + name: PlaylistTrack_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_on_conflict + PlaylistTrack_avg_fields: + description: aggregate avg on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_avg_order_by: + description: "order by avg() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_bool_exp: + description: "Boolean expression to filter rows from the table \"PlaylistTrack\". All fields are combined with a logical 'AND'." + fields: + Playlist: + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_inc_input: + description: "input type for incrementing numeric columns in table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_insert_input: + description: "input type for inserting data into table \"PlaylistTrack\"" + fields: + Playlist: + type: + type: nullable + underlying_type: + type: named + name: Playlist_obj_rel_insert_input + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_obj_rel_insert_input + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_max_fields: + description: aggregate max on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_max_order_by: + description: "order by max() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_min_fields: + description: aggregate min on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_min_order_by: + description: "order by min() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_mutation_response: + description: "response of any mutation on the table \"PlaylistTrack\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: PlaylistTrack + PlaylistTrack_on_conflict: + description: "on_conflict condition type for table \"PlaylistTrack\"" + fields: + constraint: + type: + type: named + name: PlaylistTrack_constraint + update_columns: + type: + type: array + element_type: + type: named + name: PlaylistTrack_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_order_by: + description: "Ordering options when selecting data from \"PlaylistTrack\"." + fields: + Playlist: + type: + type: nullable + underlying_type: + type: named + name: Playlist_order_by + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_pk_columns_input: + description: "primary key columns input for table: PlaylistTrack" + fields: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + PlaylistTrack_set_input: + description: "input type for updating data in table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_stddev_fields: + description: aggregate stddev on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_stddev_order_by: + description: "order by stddev() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_stream_cursor_input: + description: "Streaming cursor of the table \"PlaylistTrack\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: PlaylistTrack_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + PlaylistTrack_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_sum_fields: + description: aggregate sum on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_sum_order_by: + description: "order by sum() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_var_pop_fields: + description: aggregate var_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_var_pop_order_by: + description: "order by var_pop() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_var_samp_fields: + description: aggregate var_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_var_samp_order_by: + description: "order by var_samp() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_variance_fields: + description: aggregate variance on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_variance_order_by: + description: "order by variance() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Playlist_aggregate: + description: "aggregated selection of \"Playlist\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Playlist_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Playlist + Playlist_aggregate_fields: + description: "aggregate fields of \"Playlist\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Playlist_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Playlist_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Playlist_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Playlist_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Playlist_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Playlist_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Playlist_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Playlist_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Playlist_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Playlist_variance_fields + Playlist_avg_fields: + description: aggregate avg on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_bool_exp: + description: "Boolean expression to filter rows from the table \"Playlist\". All fields are combined with a logical 'AND'." + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_bool_exp + Playlist_insert_input: + description: "input type for inserting data into table \"Playlist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_arr_rel_insert_input + Playlist_max_fields: + description: aggregate max on columns + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_min_fields: + description: aggregate min on columns + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_mutation_response: + description: "response of any mutation on the table \"Playlist\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Playlist + Playlist_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Playlist\"" + fields: + data: + type: + type: named + name: Playlist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Playlist_on_conflict + Playlist_on_conflict: + description: "on_conflict condition type for table \"Playlist\"" + fields: + constraint: + type: + type: named + name: Playlist_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Playlist_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + Playlist_order_by: + description: "Ordering options when selecting data from \"Playlist\"." + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_order_by + Playlist_pk_columns_input: + description: "primary key columns input for table: Playlist" + fields: + PlaylistId: + type: + type: named + name: Int + Playlist_set_input: + description: "input type for updating data in table \"Playlist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Playlist_stddev_fields: + description: aggregate stddev on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_stream_cursor_input: + description: "Streaming cursor of the table \"Playlist\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Playlist_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Playlist_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_sum_fields: + description: aggregate sum on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Playlist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Playlist_bool_exp + Playlist_var_pop_fields: + description: aggregate var_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_var_samp_fields: + description: aggregate var_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_variance_fields: + description: aggregate variance on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + String_comparison_exp: + description: "Boolean expression to compare columns of type \"String\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: String + _gt: + type: + type: nullable + underlying_type: + type: named + name: String + _gte: + type: + type: nullable + underlying_type: + type: named + name: String + _ilike: + description: does the column match the given case-insensitive pattern + type: + type: nullable + underlying_type: + type: named + name: String + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: String + _iregex: + description: "does the column match the given POSIX regular expression, case insensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _like: + description: does the column match the given pattern + type: + type: nullable + underlying_type: + type: named + name: String + _lt: + type: + type: nullable + underlying_type: + type: named + name: String + _lte: + type: + type: nullable + underlying_type: + type: named + name: String + _neq: + type: + type: nullable + underlying_type: + type: named + name: String + _nilike: + description: does the column NOT match the given case-insensitive pattern + type: + type: nullable + underlying_type: + type: named + name: String + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: String + _niregex: + description: "does the column NOT match the given POSIX regular expression, case insensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _nlike: + description: does the column NOT match the given pattern + type: + type: nullable + underlying_type: + type: named + name: String + _nregex: + description: "does the column NOT match the given POSIX regular expression, case sensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _nsimilar: + description: does the column NOT match the given SQL regular expression + type: + type: nullable + underlying_type: + type: named + name: String + _regex: + description: "does the column match the given POSIX regular expression, case sensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _similar: + description: does the column match the given SQL regular expression + type: + type: nullable + underlying_type: + type: named + name: String + Track: + description: "columns and relationships of \"Track\"" + fields: + Album: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Album + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + Genre: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Genre + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLines: + description: An array relationship + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + description: An aggregate relationship + type: + type: named + name: InvoiceLine_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + MediaType: + description: An object relationship + type: + type: named + name: MediaType + MediaTypeId: + type: + type: named + name: Int + Milliseconds: + type: + type: named + name: Int + Name: + type: + type: named + name: String + PlaylistTracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + description: An aggregate relationship + type: + type: named + name: PlaylistTrack_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + TrackId: + type: + type: named + name: Int + UnitPrice: + type: + type: named + name: numeric + Track_aggregate: + description: "aggregated selection of \"Track\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Track + Track_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp_count + Track_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Track_aggregate_fields: + description: "aggregate fields of \"Track\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Track_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Track_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Track_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Track_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Track_variance_fields + Track_aggregate_order_by: + description: "order by aggregate values of table \"Track\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Track_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Track_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Track_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Track_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Track_variance_order_by + Track_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Track\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + Track_avg_fields: + description: aggregate avg on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_avg_order_by: + description: "order by avg() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_bool_exp: + description: "Boolean expression to filter rows from the table \"Track\". All fields are combined with a logical 'AND'." + fields: + Album: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Composer: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Genre: + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_bool_exp + MediaType: + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_bool_exp + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_bool_exp + Track_inc_input: + description: "input type for incrementing numeric columns in table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_insert_input: + description: "input type for inserting data into table \"Track\"" + fields: + Album: + type: + type: nullable + underlying_type: + type: named + name: Album_obj_rel_insert_input + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + Genre: + type: + type: nullable + underlying_type: + type: named + name: Genre_obj_rel_insert_input + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_arr_rel_insert_input + MediaType: + type: + type: nullable + underlying_type: + type: named + name: MediaType_obj_rel_insert_input + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_arr_rel_insert_input + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_max_fields: + description: aggregate max on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_max_order_by: + description: "order by max() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + Composer: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_min_fields: + description: aggregate min on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_min_order_by: + description: "order by min() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + Composer: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_mutation_response: + description: "response of any mutation on the table \"Track\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Track + Track_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Track\"" + fields: + data: + type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + Track_on_conflict: + description: "on_conflict condition type for table \"Track\"" + fields: + constraint: + type: + type: named + name: Track_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Track_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Track_order_by: + description: "Ordering options when selecting data from \"Track\"." + fields: + Album: + type: + type: nullable + underlying_type: + type: named + name: Album_order_by + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + Composer: + type: + type: nullable + underlying_type: + type: named + name: order_by + Genre: + type: + type: nullable + underlying_type: + type: named + name: Genre_order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_order_by + MediaType: + type: + type: nullable + underlying_type: + type: named + name: MediaType_order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_pk_columns_input: + description: "primary key columns input for table: Track" + fields: + TrackId: + type: + type: named + name: Int + Track_set_input: + description: "input type for updating data in table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_stddev_fields: + description: aggregate stddev on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_stddev_order_by: + description: "order by stddev() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_stream_cursor_input: + description: "Streaming cursor of the table \"Track\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Track_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Track_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_sum_fields: + description: aggregate sum on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_sum_order_by: + description: "order by sum() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Track_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Track_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Track_bool_exp + Track_var_pop_fields: + description: aggregate var_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_var_pop_order_by: + description: "order by var_pop() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_var_samp_fields: + description: aggregate var_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_var_samp_order_by: + description: "order by var_samp() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_variance_fields: + description: aggregate variance on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_variance_order_by: + description: "order by variance() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + numeric_comparison_exp: + description: "Boolean expression to compare columns of type \"numeric\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: numeric + _gt: + type: + type: nullable + underlying_type: + type: named + name: numeric + _gte: + type: + type: nullable + underlying_type: + type: named + name: numeric + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: numeric + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _lt: + type: + type: nullable + underlying_type: + type: named + name: numeric + _lte: + type: + type: nullable + underlying_type: + type: named + name: numeric + _neq: + type: + type: nullable + underlying_type: + type: named + name: numeric + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: numeric + subscription_root: + fields: + Album: + description: "fetch data from the table: \"Album\"" + type: + type: array + element_type: + type: named + name: Album + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Album_aggregate: + description: "fetch aggregated fields from the table: \"Album\"" + type: + type: named + name: Album_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Album_by_pk: + description: "fetch data from the table: \"Album\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Album + arguments: + AlbumId: + type: + type: named + name: Int + Album_stream: + description: "fetch data from the table in a streaming manner: \"Album\"" + type: + type: array + element_type: + type: named + name: Album + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Album_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Artist: + description: "fetch data from the table: \"Artist\"" + type: + type: array + element_type: + type: named + name: Artist + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Artist_aggregate: + description: "fetch aggregated fields from the table: \"Artist\"" + type: + type: named + name: Artist_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Artist_by_pk: + description: "fetch data from the table: \"Artist\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Artist + arguments: + ArtistId: + type: + type: named + name: Int + Artist_stream: + description: "fetch data from the table in a streaming manner: \"Artist\"" + type: + type: array + element_type: + type: named + name: Artist + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Artist_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Customer: + description: "fetch data from the table: \"Customer\"" + type: + type: array + element_type: + type: named + name: Customer + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customer_aggregate: + description: "fetch aggregated fields from the table: \"Customer\"" + type: + type: named + name: Customer_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customer_by_pk: + description: "fetch data from the table: \"Customer\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Customer + arguments: + CustomerId: + type: + type: named + name: Int + Customer_stream: + description: "fetch data from the table in a streaming manner: \"Customer\"" + type: + type: array + element_type: + type: named + name: Customer + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Customer_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Employee: + description: "fetch data from the table: \"Employee\"" + type: + type: array + element_type: + type: named + name: Employee + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employee_aggregate: + description: "fetch aggregated fields from the table: \"Employee\"" + type: + type: named + name: Employee_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employee_by_pk: + description: "fetch data from the table: \"Employee\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Employee + arguments: + EmployeeId: + type: + type: named + name: Int + Employee_stream: + description: "fetch data from the table in a streaming manner: \"Employee\"" + type: + type: array + element_type: + type: named + name: Employee + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Employee_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Genre: + description: "fetch data from the table: \"Genre\"" + type: + type: array + element_type: + type: named + name: Genre + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Genre_aggregate: + description: "fetch aggregated fields from the table: \"Genre\"" + type: + type: named + name: Genre_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Genre_by_pk: + description: "fetch data from the table: \"Genre\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Genre + arguments: + GenreId: + type: + type: named + name: Int + Genre_stream: + description: "fetch data from the table in a streaming manner: \"Genre\"" + type: + type: array + element_type: + type: named + name: Genre + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Genre_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Invoice: + description: "fetch data from the table: \"Invoice\"" + type: + type: array + element_type: + type: named + name: Invoice + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + InvoiceLine: + description: "fetch data from the table: \"InvoiceLine\"" + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_aggregate: + description: "fetch aggregated fields from the table: \"InvoiceLine\"" + type: + type: named + name: InvoiceLine_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_by_pk: + description: "fetch data from the table: \"InvoiceLine\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + arguments: + InvoiceLineId: + type: + type: named + name: Int + InvoiceLine_stream: + description: "fetch data from the table in a streaming manner: \"InvoiceLine\"" + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + Invoice_aggregate: + description: "fetch aggregated fields from the table: \"Invoice\"" + type: + type: named + name: Invoice_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoice_by_pk: + description: "fetch data from the table: \"Invoice\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Invoice + arguments: + InvoiceId: + type: + type: named + name: Int + Invoice_stream: + description: "fetch data from the table in a streaming manner: \"Invoice\"" + type: + type: array + element_type: + type: named + name: Invoice + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Invoice_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + MediaType: + description: "fetch data from the table: \"MediaType\"" + type: + type: array + element_type: + type: named + name: MediaType + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaType_aggregate: + description: "fetch aggregated fields from the table: \"MediaType\"" + type: + type: named + name: MediaType_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaType_by_pk: + description: "fetch data from the table: \"MediaType\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: MediaType + arguments: + MediaTypeId: + type: + type: named + name: Int + MediaType_stream: + description: "fetch data from the table in a streaming manner: \"MediaType\"" + type: + type: array + element_type: + type: named + name: MediaType + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: MediaType_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + Playlist: + description: "fetch data from the table: \"Playlist\"" + type: + type: array + element_type: + type: named + name: Playlist + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + PlaylistTrack: + description: "fetch data from the table: \"PlaylistTrack\"" + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_aggregate: + description: "fetch aggregated fields from the table: \"PlaylistTrack\"" + type: + type: named + name: PlaylistTrack_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_by_pk: + description: "fetch data from the table: \"PlaylistTrack\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + arguments: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + PlaylistTrack_stream: + description: "fetch data from the table in a streaming manner: \"PlaylistTrack\"" + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + Playlist_aggregate: + description: "fetch aggregated fields from the table: \"Playlist\"" + type: + type: named + name: Playlist_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + Playlist_by_pk: + description: "fetch data from the table: \"Playlist\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Playlist + arguments: + PlaylistId: + type: + type: named + name: Int + Playlist_stream: + description: "fetch data from the table in a streaming manner: \"Playlist\"" + type: + type: array + element_type: + type: named + name: Playlist + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Playlist_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + Track: + description: "fetch data from the table: \"Track\"" + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Track_aggregate: + description: "fetch aggregated fields from the table: \"Track\"" + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Track_by_pk: + description: "fetch data from the table: \"Track\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Track + arguments: + TrackId: + type: + type: named + name: Int + Track_stream: + description: "fetch data from the table in a streaming manner: \"Track\"" + type: + type: array + element_type: + type: named + name: Track + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Track_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + timestamp_comparison_exp: + description: "Boolean expression to compare columns of type \"timestamp\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _gt: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _gte: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: timestamp + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _lt: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _lte: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _neq: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: timestamp +collections: [] +functions: + - name: Album + description: "fetch data from the table: \"Album\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + result_type: + type: array + element_type: + type: named + name: Album + - name: Album_aggregate + description: "fetch aggregated fields from the table: \"Album\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + result_type: + type: named + name: Album_aggregate + - name: Album_by_pk + description: "fetch data from the table: \"Album\" using primary key columns" + arguments: + AlbumId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Album + - name: Artist + description: "fetch data from the table: \"Artist\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + result_type: + type: array + element_type: + type: named + name: Artist + - name: Artist_aggregate + description: "fetch aggregated fields from the table: \"Artist\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + result_type: + type: named + name: Artist_aggregate + - name: Artist_by_pk + description: "fetch data from the table: \"Artist\" using primary key columns" + arguments: + ArtistId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Artist + - name: Customer + description: "fetch data from the table: \"Customer\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + result_type: + type: array + element_type: + type: named + name: Customer + - name: Customer_aggregate + description: "fetch aggregated fields from the table: \"Customer\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + result_type: + type: named + name: Customer_aggregate + - name: Customer_by_pk + description: "fetch data from the table: \"Customer\" using primary key columns" + arguments: + CustomerId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Customer + - name: Employee + description: "fetch data from the table: \"Employee\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + result_type: + type: array + element_type: + type: named + name: Employee + - name: Employee_aggregate + description: "fetch aggregated fields from the table: \"Employee\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + result_type: + type: named + name: Employee_aggregate + - name: Employee_by_pk + description: "fetch data from the table: \"Employee\" using primary key columns" + arguments: + EmployeeId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Employee + - name: Genre + description: "fetch data from the table: \"Genre\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + result_type: + type: array + element_type: + type: named + name: Genre + - name: Genre_aggregate + description: "fetch aggregated fields from the table: \"Genre\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + result_type: + type: named + name: Genre_aggregate + - name: Genre_by_pk + description: "fetch data from the table: \"Genre\" using primary key columns" + arguments: + GenreId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Genre + - name: Invoice + description: "fetch data from the table: \"Invoice\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + result_type: + type: array + element_type: + type: named + name: Invoice + - name: InvoiceLine + description: "fetch data from the table: \"InvoiceLine\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: array + element_type: + type: named + name: InvoiceLine + - name: InvoiceLine_aggregate + description: "fetch aggregated fields from the table: \"InvoiceLine\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: named + name: InvoiceLine_aggregate + - name: InvoiceLine_by_pk + description: "fetch data from the table: \"InvoiceLine\" using primary key columns" + arguments: + InvoiceLineId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + - name: Invoice_aggregate + description: "fetch aggregated fields from the table: \"Invoice\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + result_type: + type: named + name: Invoice_aggregate + - name: Invoice_by_pk + description: "fetch data from the table: \"Invoice\" using primary key columns" + arguments: + InvoiceId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Invoice + - name: MediaType + description: "fetch data from the table: \"MediaType\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + result_type: + type: array + element_type: + type: named + name: MediaType + - name: MediaType_aggregate + description: "fetch aggregated fields from the table: \"MediaType\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + result_type: + type: named + name: MediaType_aggregate + - name: MediaType_by_pk + description: "fetch data from the table: \"MediaType\" using primary key columns" + arguments: + MediaTypeId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: MediaType + - name: Playlist + description: "fetch data from the table: \"Playlist\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + result_type: + type: array + element_type: + type: named + name: Playlist + - name: PlaylistTrack + description: "fetch data from the table: \"PlaylistTrack\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: array + element_type: + type: named + name: PlaylistTrack + - name: PlaylistTrack_aggregate + description: "fetch aggregated fields from the table: \"PlaylistTrack\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: named + name: PlaylistTrack_aggregate + - name: PlaylistTrack_by_pk + description: "fetch data from the table: \"PlaylistTrack\" using primary key columns" + arguments: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + - name: Playlist_aggregate + description: "fetch aggregated fields from the table: \"Playlist\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + result_type: + type: named + name: Playlist_aggregate + - name: Playlist_by_pk + description: "fetch data from the table: \"Playlist\" using primary key columns" + arguments: + PlaylistId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Playlist + - name: Track + description: "fetch data from the table: \"Track\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + result_type: + type: array + element_type: + type: named + name: Track + - name: Track_aggregate + description: "fetch aggregated fields from the table: \"Track\"" + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + result_type: + type: named + name: Track_aggregate + - name: Track_by_pk + description: "fetch data from the table: \"Track\" using primary key columns" + arguments: + TrackId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Track +procedures: + - name: delete_Album + description: "delete data from the table: \"Album\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: Album_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + - name: delete_Album_by_pk + description: "delete single row from the table: \"Album\"" + arguments: + AlbumId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Album + - name: delete_Artist + description: "delete data from the table: \"Artist\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: Artist_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + - name: delete_Artist_by_pk + description: "delete single row from the table: \"Artist\"" + arguments: + ArtistId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Artist + - name: delete_Customer + description: "delete data from the table: \"Customer\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: Customer_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + - name: delete_Customer_by_pk + description: "delete single row from the table: \"Customer\"" + arguments: + CustomerId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Customer + - name: delete_Employee + description: "delete data from the table: \"Employee\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: Employee_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + - name: delete_Employee_by_pk + description: "delete single row from the table: \"Employee\"" + arguments: + EmployeeId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Employee + - name: delete_Genre + description: "delete data from the table: \"Genre\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: Genre_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + - name: delete_Genre_by_pk + description: "delete single row from the table: \"Genre\"" + arguments: + GenreId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Genre + - name: delete_Invoice + description: "delete data from the table: \"Invoice\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: Invoice_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + - name: delete_InvoiceLine + description: "delete data from the table: \"InvoiceLine\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + - name: delete_InvoiceLine_by_pk + description: "delete single row from the table: \"InvoiceLine\"" + arguments: + InvoiceLineId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + - name: delete_Invoice_by_pk + description: "delete single row from the table: \"Invoice\"" + arguments: + InvoiceId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Invoice + - name: delete_MediaType + description: "delete data from the table: \"MediaType\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: MediaType_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + - name: delete_MediaType_by_pk + description: "delete single row from the table: \"MediaType\"" + arguments: + MediaTypeId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: MediaType + - name: delete_Playlist + description: "delete data from the table: \"Playlist\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: Playlist_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + - name: delete_PlaylistTrack + description: "delete data from the table: \"PlaylistTrack\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + - name: delete_PlaylistTrack_by_pk + description: "delete single row from the table: \"PlaylistTrack\"" + arguments: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + - name: delete_Playlist_by_pk + description: "delete single row from the table: \"Playlist\"" + arguments: + PlaylistId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Playlist + - name: delete_Track + description: "delete data from the table: \"Track\"" + arguments: + where: + description: filter the rows which have to be deleted + type: + type: named + name: Track_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + - name: delete_Track_by_pk + description: "delete single row from the table: \"Track\"" + arguments: + TrackId: + type: + type: named + name: Int + result_type: + type: nullable + underlying_type: + type: named + name: Track + - name: insert_Album + description: "insert data into the table: \"Album\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + - name: insert_Album_one + description: "insert a single row into the table: \"Album\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Album + - name: insert_Artist + description: "insert data into the table: \"Artist\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Artist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Artist_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + - name: insert_Artist_one + description: "insert a single row into the table: \"Artist\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: Artist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Artist_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Artist + - name: insert_Customer + description: "insert data into the table: \"Customer\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + - name: insert_Customer_one + description: "insert a single row into the table: \"Customer\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Customer + - name: insert_Employee + description: "insert data into the table: \"Employee\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + - name: insert_Employee_one + description: "insert a single row into the table: \"Employee\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Employee + - name: insert_Genre + description: "insert data into the table: \"Genre\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Genre_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Genre_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + - name: insert_Genre_one + description: "insert a single row into the table: \"Genre\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: Genre_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Genre_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Genre + - name: insert_Invoice + description: "insert data into the table: \"Invoice\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + - name: insert_InvoiceLine + description: "insert data into the table: \"InvoiceLine\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: InvoiceLine_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + - name: insert_InvoiceLine_one + description: "insert a single row into the table: \"InvoiceLine\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: InvoiceLine_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + - name: insert_Invoice_one + description: "insert a single row into the table: \"Invoice\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Invoice + - name: insert_MediaType + description: "insert data into the table: \"MediaType\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: MediaType_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: MediaType_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + - name: insert_MediaType_one + description: "insert a single row into the table: \"MediaType\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: MediaType_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: MediaType_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: MediaType + - name: insert_Playlist + description: "insert data into the table: \"Playlist\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Playlist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Playlist_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + - name: insert_PlaylistTrack + description: "insert data into the table: \"PlaylistTrack\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: PlaylistTrack_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + - name: insert_PlaylistTrack_one + description: "insert a single row into the table: \"PlaylistTrack\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: PlaylistTrack_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + - name: insert_Playlist_one + description: "insert a single row into the table: \"Playlist\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: Playlist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Playlist_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Playlist + - name: insert_Track + description: "insert data into the table: \"Track\"" + arguments: + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + - name: insert_Track_one + description: "insert a single row into the table: \"Track\"" + arguments: + object: + description: the row to be inserted + type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + result_type: + type: nullable + underlying_type: + type: named + name: Track + - name: update_Album + description: "update data of the table: \"Album\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Album_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Album_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Album_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + - name: update_Album_by_pk + description: "update single row of the table: \"Album\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Album_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Album_set_input + pk_columns: + type: + type: named + name: Album_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: Album + - name: update_Album_many + description: "update multiples rows of table: \"Album\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Album_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + - name: update_Artist + description: "update data of the table: \"Artist\"" + arguments: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Artist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Artist_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + - name: update_Artist_by_pk + description: "update single row of the table: \"Artist\"" + arguments: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Artist_set_input + pk_columns: + type: + type: named + name: Artist_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: Artist + - name: update_Artist_many + description: "update multiples rows of table: \"Artist\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Artist_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + - name: update_Customer + description: "update data of the table: \"Customer\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Customer_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Customer_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Customer_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + - name: update_Customer_by_pk + description: "update single row of the table: \"Customer\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Customer_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Customer_set_input + pk_columns: + type: + type: named + name: Customer_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: Customer + - name: update_Customer_many + description: "update multiples rows of table: \"Customer\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Customer_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + - name: update_Employee + description: "update data of the table: \"Employee\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Employee_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Employee_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Employee_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + - name: update_Employee_by_pk + description: "update single row of the table: \"Employee\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Employee_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Employee_set_input + pk_columns: + type: + type: named + name: Employee_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: Employee + - name: update_Employee_many + description: "update multiples rows of table: \"Employee\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Employee_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + - name: update_Genre + description: "update data of the table: \"Genre\"" + arguments: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Genre_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Genre_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + - name: update_Genre_by_pk + description: "update single row of the table: \"Genre\"" + arguments: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Genre_set_input + pk_columns: + type: + type: named + name: Genre_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: Genre + - name: update_Genre_many + description: "update multiples rows of table: \"Genre\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Genre_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + - name: update_Invoice + description: "update data of the table: \"Invoice\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Invoice_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Invoice_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Invoice_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + - name: update_InvoiceLine + description: "update data of the table: \"InvoiceLine\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + - name: update_InvoiceLine_by_pk + description: "update single row of the table: \"InvoiceLine\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_set_input + pk_columns: + type: + type: named + name: InvoiceLine_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + - name: update_InvoiceLine_many + description: "update multiples rows of table: \"InvoiceLine\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: InvoiceLine_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + - name: update_Invoice_by_pk + description: "update single row of the table: \"Invoice\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Invoice_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Invoice_set_input + pk_columns: + type: + type: named + name: Invoice_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: Invoice + - name: update_Invoice_many + description: "update multiples rows of table: \"Invoice\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Invoice_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + - name: update_MediaType + description: "update data of the table: \"MediaType\"" + arguments: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: MediaType_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: MediaType_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + - name: update_MediaType_by_pk + description: "update single row of the table: \"MediaType\"" + arguments: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: MediaType_set_input + pk_columns: + type: + type: named + name: MediaType_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: MediaType + - name: update_MediaType_many + description: "update multiples rows of table: \"MediaType\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: MediaType_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + - name: update_Playlist + description: "update data of the table: \"Playlist\"" + arguments: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Playlist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Playlist_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + - name: update_PlaylistTrack + description: "update data of the table: \"PlaylistTrack\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + - name: update_PlaylistTrack_by_pk + description: "update single row of the table: \"PlaylistTrack\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_set_input + pk_columns: + type: + type: named + name: PlaylistTrack_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + - name: update_PlaylistTrack_many + description: "update multiples rows of table: \"PlaylistTrack\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: PlaylistTrack_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + - name: update_Playlist_by_pk + description: "update single row of the table: \"Playlist\"" + arguments: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Playlist_set_input + pk_columns: + type: + type: named + name: Playlist_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: Playlist + - name: update_Playlist_many + description: "update multiples rows of table: \"Playlist\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Playlist_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + - name: update_Track + description: "update data of the table: \"Track\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Track_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Track_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Track_bool_exp + result_type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + - name: update_Track_by_pk + description: "update single row of the table: \"Track\"" + arguments: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Track_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Track_set_input + pk_columns: + type: + type: named + name: Track_pk_columns_input + result_type: + type: nullable + underlying_type: + type: named + name: Track + - name: update_Track_many + description: "update multiples rows of table: \"Track\"" + arguments: + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Track_updates + result_type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__config-2 NDC Schema.snap b/crates/ndc-graphql/tests/snapshots/query_builder__config-2 NDC Schema.snap new file mode 100644 index 0000000..2c24e07 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__config-2 NDC Schema.snap @@ -0,0 +1,17890 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: schema +--- +scalar_types: + Album_constraint: + representation: + type: enum + one_of: + - PK_Album + aggregate_functions: {} + comparison_operators: {} + Album_select_column: + representation: + type: enum + one_of: + - AlbumId + - ArtistId + - Title + aggregate_functions: {} + comparison_operators: {} + Album_update_column: + representation: + type: enum + one_of: + - ArtistId + - Title + aggregate_functions: {} + comparison_operators: {} + Artist_constraint: + representation: + type: enum + one_of: + - PK_Artist + aggregate_functions: {} + comparison_operators: {} + Artist_select_column: + representation: + type: enum + one_of: + - ArtistId + - Name + aggregate_functions: {} + comparison_operators: {} + Artist_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + Boolean: + aggregate_functions: {} + comparison_operators: {} + Customer_constraint: + representation: + type: enum + one_of: + - PK_Customer + aggregate_functions: {} + comparison_operators: {} + Customer_select_column: + representation: + type: enum + one_of: + - Address + - City + - Company + - Country + - CustomerId + - Email + - Fax + - FirstName + - LastName + - Phone + - PostalCode + - State + - SupportRepId + aggregate_functions: {} + comparison_operators: {} + Customer_update_column: + representation: + type: enum + one_of: + - Address + - City + - Company + - Country + - Email + - Fax + - FirstName + - LastName + - Phone + - PostalCode + - State + - SupportRepId + aggregate_functions: {} + comparison_operators: {} + Employee_constraint: + representation: + type: enum + one_of: + - PK_Employee + aggregate_functions: {} + comparison_operators: {} + Employee_select_column: + representation: + type: enum + one_of: + - Address + - BirthDate + - City + - Country + - Email + - EmployeeId + - Fax + - FirstName + - HireDate + - LastName + - Phone + - PostalCode + - ReportsTo + - State + - Title + aggregate_functions: {} + comparison_operators: {} + Employee_update_column: + representation: + type: enum + one_of: + - Address + - BirthDate + - City + - Country + - Email + - Fax + - FirstName + - HireDate + - LastName + - Phone + - PostalCode + - ReportsTo + - State + - Title + aggregate_functions: {} + comparison_operators: {} + Float: + aggregate_functions: {} + comparison_operators: {} + Genre_constraint: + representation: + type: enum + one_of: + - PK_Genre + aggregate_functions: {} + comparison_operators: {} + Genre_select_column: + representation: + type: enum + one_of: + - GenreId + - Name + aggregate_functions: {} + comparison_operators: {} + Genre_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + Int: + aggregate_functions: {} + comparison_operators: {} + InvoiceLine_constraint: + representation: + type: enum + one_of: + - PK_InvoiceLine + aggregate_functions: {} + comparison_operators: {} + InvoiceLine_select_column: + representation: + type: enum + one_of: + - InvoiceId + - InvoiceLineId + - Quantity + - TrackId + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + InvoiceLine_update_column: + representation: + type: enum + one_of: + - InvoiceId + - Quantity + - TrackId + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + Invoice_constraint: + representation: + type: enum + one_of: + - PK_Invoice + aggregate_functions: {} + comparison_operators: {} + Invoice_select_column: + representation: + type: enum + one_of: + - BillingAddress + - BillingCity + - BillingCountry + - BillingPostalCode + - BillingState + - CustomerId + - InvoiceDate + - InvoiceId + - Total + aggregate_functions: {} + comparison_operators: {} + Invoice_update_column: + representation: + type: enum + one_of: + - BillingAddress + - BillingCity + - BillingCountry + - BillingPostalCode + - BillingState + - CustomerId + - InvoiceDate + - Total + aggregate_functions: {} + comparison_operators: {} + MediaType_constraint: + representation: + type: enum + one_of: + - PK_MediaType + aggregate_functions: {} + comparison_operators: {} + MediaType_select_column: + representation: + type: enum + one_of: + - MediaTypeId + - Name + aggregate_functions: {} + comparison_operators: {} + MediaType_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + PlaylistTrack_constraint: + representation: + type: enum + one_of: + - PK_PlaylistTrack + aggregate_functions: {} + comparison_operators: {} + PlaylistTrack_select_column: + representation: + type: enum + one_of: + - PlaylistId + - TrackId + aggregate_functions: {} + comparison_operators: {} + PlaylistTrack_update_column: + representation: + type: enum + one_of: + - PlaylistId + - TrackId + aggregate_functions: {} + comparison_operators: {} + Playlist_constraint: + representation: + type: enum + one_of: + - PK_Playlist + aggregate_functions: {} + comparison_operators: {} + Playlist_select_column: + representation: + type: enum + one_of: + - Name + - PlaylistId + aggregate_functions: {} + comparison_operators: {} + Playlist_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + String: + aggregate_functions: {} + comparison_operators: {} + Track_constraint: + representation: + type: enum + one_of: + - PK_Track + aggregate_functions: {} + comparison_operators: {} + Track_select_column: + representation: + type: enum + one_of: + - AlbumId + - Bytes + - Composer + - GenreId + - MediaTypeId + - Milliseconds + - Name + - TrackId + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + Track_update_column: + representation: + type: enum + one_of: + - AlbumId + - Bytes + - Composer + - GenreId + - MediaTypeId + - Milliseconds + - Name + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + _HeaderMap: + representation: + type: json + aggregate_functions: {} + comparison_operators: {} + cursor_ordering: + representation: + type: enum + one_of: + - ASC + - DESC + aggregate_functions: {} + comparison_operators: {} + numeric: + aggregate_functions: {} + comparison_operators: {} + order_by: + representation: + type: enum + one_of: + - asc + - asc_nulls_first + - asc_nulls_last + - desc + - desc_nulls_first + - desc_nulls_last + aggregate_functions: {} + comparison_operators: {} + timestamp: + aggregate_functions: {} + comparison_operators: {} +object_types: + Album: + description: "columns and relationships of \"Album\"" + fields: + AlbumId: + type: + type: named + name: Int + Artist: + description: An object relationship + type: + type: named + name: Artist + ArtistId: + type: + type: named + name: Int + Title: + type: + type: named + name: String + Tracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + description: An aggregate relationship + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Album_aggregate: + description: "aggregated selection of \"Album\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Album + Album_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_bool_exp_count + Album_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Album_aggregate_fields: + description: "aggregate fields of \"Album\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Album_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Album_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Album_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Album_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Album_variance_fields + Album_aggregate_order_by: + description: "order by aggregate values of table \"Album\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Album_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Album_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Album_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Album_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Album_variance_order_by + Album_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Album\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + Album_avg_fields: + description: aggregate avg on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_avg_order_by: + description: "order by avg() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_bool_exp: + description: "Boolean expression to filter rows from the table \"Album\". All fields are combined with a logical 'AND'." + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Artist: + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Title: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_bool_exp + Album_inc_input: + description: "input type for incrementing numeric columns in table \"Album\"" + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Album_insert_input: + description: "input type for inserting data into table \"Album\"" + fields: + Artist: + type: + type: nullable + underlying_type: + type: named + name: Artist_obj_rel_insert_input + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_arr_rel_insert_input + Album_max_fields: + description: aggregate max on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_max_order_by: + description: "order by max() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_min_fields: + description: aggregate min on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_min_order_by: + description: "order by min() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_mutation_response: + description: "response of any mutation on the table \"Album\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Album + Album_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Album\"" + fields: + data: + type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + Album_on_conflict: + description: "on_conflict condition type for table \"Album\"" + fields: + constraint: + type: + type: named + name: Album_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Album_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Album_order_by: + description: "Ordering options when selecting data from \"Album\"." + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Artist: + type: + type: nullable + underlying_type: + type: named + name: Artist_order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_order_by + Album_pk_columns_input: + description: "primary key columns input for table: Album" + fields: + AlbumId: + type: + type: named + name: Int + Album_set_input: + description: "input type for updating data in table \"Album\"" + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_stddev_fields: + description: aggregate stddev on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_stddev_order_by: + description: "order by stddev() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_stream_cursor_input: + description: "Streaming cursor of the table \"Album\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Album_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Album_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_sum_fields: + description: aggregate sum on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Album_sum_order_by: + description: "order by sum() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Album_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Album_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Album_bool_exp + Album_var_pop_fields: + description: aggregate var_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_var_pop_order_by: + description: "order by var_pop() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_var_samp_fields: + description: aggregate var_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_var_samp_order_by: + description: "order by var_samp() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_variance_fields: + description: aggregate variance on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_variance_order_by: + description: "order by variance() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Artist: + description: "columns and relationships of \"Artist\"" + fields: + Albums: + description: An array relationship + type: + type: array + element_type: + type: named + name: Album + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Albums_aggregate: + description: An aggregate relationship + type: + type: named + name: Album_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + ArtistId: + type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_aggregate: + description: "aggregated selection of \"Artist\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Artist_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Artist + Artist_aggregate_fields: + description: "aggregate fields of \"Artist\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Artist_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Artist_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Artist_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Artist_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Artist_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Artist_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Artist_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Artist_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Artist_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Artist_variance_fields + Artist_avg_fields: + description: aggregate avg on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_bool_exp: + description: "Boolean expression to filter rows from the table \"Artist\". All fields are combined with a logical 'AND'." + fields: + Albums: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Albums_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_bool_exp + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_bool_exp + Artist_insert_input: + description: "input type for inserting data into table \"Artist\"" + fields: + Albums: + type: + type: nullable + underlying_type: + type: named + name: Album_arr_rel_insert_input + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_max_fields: + description: aggregate max on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_min_fields: + description: aggregate min on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_mutation_response: + description: "response of any mutation on the table \"Artist\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Artist + Artist_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Artist\"" + fields: + data: + type: + type: named + name: Artist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Artist_on_conflict + Artist_on_conflict: + description: "on_conflict condition type for table \"Artist\"" + fields: + constraint: + type: + type: named + name: Artist_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Artist_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Artist_order_by: + description: "Ordering options when selecting data from \"Artist\"." + fields: + Albums_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + Artist_pk_columns_input: + description: "primary key columns input for table: Artist" + fields: + ArtistId: + type: + type: named + name: Int + Artist_set_input: + description: "input type for updating data in table \"Artist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_stddev_fields: + description: aggregate stddev on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_stream_cursor_input: + description: "Streaming cursor of the table \"Artist\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Artist_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Artist_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_sum_fields: + description: aggregate sum on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Artist_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Artist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Artist_bool_exp + Artist_var_pop_fields: + description: aggregate var_pop on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_var_samp_fields: + description: aggregate var_samp on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_variance_fields: + description: aggregate variance on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer: + description: "columns and relationships of \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: named + name: Int + Email: + type: + type: named + name: String + Employee: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Employee + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: named + name: String + Invoices: + description: An array relationship + type: + type: array + element_type: + type: named + name: Invoice + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoices_aggregate: + description: An aggregate relationship + type: + type: named + name: Invoice_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + LastName: + type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_aggregate: + description: "aggregated selection of \"Customer\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Customer + Customer_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_bool_exp_count + Customer_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Customer_aggregate_fields: + description: "aggregate fields of \"Customer\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Customer_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Customer_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Customer_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Customer_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Customer_variance_fields + Customer_aggregate_order_by: + description: "order by aggregate values of table \"Customer\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Customer_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Customer_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Customer_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Customer_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Customer_variance_order_by + Customer_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Customer\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + Customer_avg_fields: + description: aggregate avg on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_avg_order_by: + description: "order by avg() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_bool_exp: + description: "Boolean expression to filter rows from the table \"Customer\". All fields are combined with a logical 'AND'." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + City: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Company: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Country: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Email: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Fax: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Invoices: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoices_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_bool_exp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Phone: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + State: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_bool_exp + Customer_inc_input: + description: "input type for incrementing numeric columns in table \"Customer\"" + fields: + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_insert_input: + description: "input type for inserting data into table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_obj_rel_insert_input + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + Invoices: + type: + type: nullable + underlying_type: + type: named + name: Invoice_arr_rel_insert_input + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_max_fields: + description: aggregate max on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_max_order_by: + description: "order by max() on columns of table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Company: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_min_fields: + description: aggregate min on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_min_order_by: + description: "order by min() on columns of table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Company: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_mutation_response: + description: "response of any mutation on the table \"Customer\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Customer + Customer_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Customer\"" + fields: + data: + type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + Customer_on_conflict: + description: "on_conflict condition type for table \"Customer\"" + fields: + constraint: + type: + type: named + name: Customer_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Customer_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customer_order_by: + description: "Ordering options when selecting data from \"Customer\"." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Company: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoices_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_pk_columns_input: + description: "primary key columns input for table: Customer" + fields: + CustomerId: + type: + type: named + name: Int + Customer_set_input: + description: "input type for updating data in table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_stddev_fields: + description: aggregate stddev on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_stddev_order_by: + description: "order by stddev() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_stream_cursor_input: + description: "Streaming cursor of the table \"Customer\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Customer_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Customer_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_sum_fields: + description: aggregate sum on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_sum_order_by: + description: "order by sum() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Customer_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Customer_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Customer_bool_exp + Customer_var_pop_fields: + description: aggregate var_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_var_pop_order_by: + description: "order by var_pop() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_var_samp_fields: + description: aggregate var_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_var_samp_order_by: + description: "order by var_samp() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_variance_fields: + description: aggregate variance on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_variance_order_by: + description: "order by variance() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee: + description: "columns and relationships of \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Customers: + description: An array relationship + type: + type: array + element_type: + type: named + name: Customer + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customers_aggregate: + description: An aggregate relationship + type: + type: named + name: Customer_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Employee: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Employee + EmployeeId: + type: + type: named + name: Int + Employees: + description: An array relationship + type: + type: array + element_type: + type: named + name: Employee + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employees_aggregate: + description: An aggregate relationship + type: + type: named + name: Employee_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_aggregate: + description: "aggregated selection of \"Employee\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Employee + Employee_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_bool_exp_count + Employee_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Employee_aggregate_fields: + description: "aggregate fields of \"Employee\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Employee_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Employee_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Employee_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Employee_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Employee_variance_fields + Employee_aggregate_order_by: + description: "order by aggregate values of table \"Employee\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Employee_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Employee_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Employee_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Employee_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Employee_variance_order_by + Employee_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Employee\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + Employee_avg_fields: + description: aggregate avg on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_avg_order_by: + description: "order by avg() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_bool_exp: + description: "Boolean expression to filter rows from the table \"Employee\". All fields are combined with a logical 'AND'." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp_comparison_exp + City: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Country: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Customers: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customers_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_bool_exp + Email: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Employees: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employees_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_bool_exp + Fax: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp_comparison_exp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Phone: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + State: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Title: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_bool_exp + Employee_inc_input: + description: "input type for incrementing numeric columns in table \"Employee\"" + fields: + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + Employee_insert_input: + description: "input type for inserting data into table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Customers: + type: + type: nullable + underlying_type: + type: named + name: Customer_arr_rel_insert_input + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_obj_rel_insert_input + Employees: + type: + type: nullable + underlying_type: + type: named + name: Employee_arr_rel_insert_input + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_max_fields: + description: aggregate max on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_max_order_by: + description: "order by max() on columns of table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + HireDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_min_fields: + description: aggregate min on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_min_order_by: + description: "order by min() on columns of table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + HireDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_mutation_response: + description: "response of any mutation on the table \"Employee\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Employee + Employee_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Employee\"" + fields: + data: + type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + Employee_on_conflict: + description: "on_conflict condition type for table \"Employee\"" + fields: + constraint: + type: + type: named + name: Employee_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Employee_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employee_order_by: + description: "Ordering options when selecting data from \"Employee\"." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customers_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_order_by + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employees_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + HireDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_pk_columns_input: + description: "primary key columns input for table: Employee" + fields: + EmployeeId: + type: + type: named + name: Int + Employee_set_input: + description: "input type for updating data in table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_stddev_fields: + description: aggregate stddev on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_stddev_order_by: + description: "order by stddev() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_stream_cursor_input: + description: "Streaming cursor of the table \"Employee\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Employee_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Employee_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_sum_fields: + description: aggregate sum on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + Employee_sum_order_by: + description: "order by sum() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Employee_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Employee_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Employee_bool_exp + Employee_var_pop_fields: + description: aggregate var_pop on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_var_pop_order_by: + description: "order by var_pop() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_var_samp_fields: + description: aggregate var_samp on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_var_samp_order_by: + description: "order by var_samp() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_variance_fields: + description: aggregate variance on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_variance_order_by: + description: "order by variance() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Genre: + description: "columns and relationships of \"Genre\"" + fields: + GenreId: + type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + description: An aggregate relationship + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Genre_aggregate: + description: "aggregated selection of \"Genre\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Genre_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Genre + Genre_aggregate_fields: + description: "aggregate fields of \"Genre\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Genre_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Genre_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Genre_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Genre_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Genre_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Genre_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Genre_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Genre_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Genre_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Genre_variance_fields + Genre_avg_fields: + description: aggregate avg on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_bool_exp: + description: "Boolean expression to filter rows from the table \"Genre\". All fields are combined with a logical 'AND'." + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_bool_exp + Genre_insert_input: + description: "input type for inserting data into table \"Genre\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_arr_rel_insert_input + Genre_max_fields: + description: aggregate max on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_min_fields: + description: aggregate min on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_mutation_response: + description: "response of any mutation on the table \"Genre\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Genre + Genre_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Genre\"" + fields: + data: + type: + type: named + name: Genre_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Genre_on_conflict + Genre_on_conflict: + description: "on_conflict condition type for table \"Genre\"" + fields: + constraint: + type: + type: named + name: Genre_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Genre_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Genre_order_by: + description: "Ordering options when selecting data from \"Genre\"." + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_order_by + Genre_pk_columns_input: + description: "primary key columns input for table: Genre" + fields: + GenreId: + type: + type: named + name: Int + Genre_set_input: + description: "input type for updating data in table \"Genre\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_stddev_fields: + description: aggregate stddev on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_stream_cursor_input: + description: "Streaming cursor of the table \"Genre\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Genre_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Genre_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_sum_fields: + description: aggregate sum on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Genre_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Genre_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Genre_bool_exp + Genre_var_pop_fields: + description: aggregate var_pop on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_var_samp_fields: + description: aggregate var_samp on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_variance_fields: + description: aggregate variance on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Int_comparison_exp: + description: "Boolean expression to compare columns of type \"Int\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: Int + _gt: + type: + type: nullable + underlying_type: + type: named + name: Int + _gte: + type: + type: nullable + underlying_type: + type: named + name: Int + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Int + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _lt: + type: + type: nullable + underlying_type: + type: named + name: Int + _lte: + type: + type: nullable + underlying_type: + type: named + name: Int + _neq: + type: + type: nullable + underlying_type: + type: named + name: Int + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Int + Invoice: + description: "columns and relationships of \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + Customer: + description: An object relationship + type: + type: named + name: Customer + CustomerId: + type: + type: named + name: Int + InvoiceDate: + type: + type: named + name: timestamp + InvoiceId: + type: + type: named + name: Int + InvoiceLines: + description: An array relationship + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + description: An aggregate relationship + type: + type: named + name: InvoiceLine_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + Total: + type: + type: named + name: numeric + InvoiceLine: + description: "columns and relationships of \"InvoiceLine\"" + fields: + Invoice: + description: An object relationship + type: + type: named + name: Invoice + InvoiceId: + type: + type: named + name: Int + InvoiceLineId: + type: + type: named + name: Int + Quantity: + type: + type: named + name: Int + Track: + description: An object relationship + type: + type: named + name: Track + TrackId: + type: + type: named + name: Int + UnitPrice: + type: + type: named + name: numeric + InvoiceLine_aggregate: + description: "aggregated selection of \"InvoiceLine\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: InvoiceLine + InvoiceLine_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_bool_exp_count + InvoiceLine_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + InvoiceLine_aggregate_fields: + description: "aggregate fields of \"InvoiceLine\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_variance_fields + InvoiceLine_aggregate_order_by: + description: "order by aggregate values of table \"InvoiceLine\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_variance_order_by + InvoiceLine_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"InvoiceLine\"" + fields: + data: + type: + type: array + element_type: + type: named + name: InvoiceLine_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_on_conflict + InvoiceLine_avg_fields: + description: aggregate avg on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_avg_order_by: + description: "order by avg() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_bool_exp: + description: "Boolean expression to filter rows from the table \"InvoiceLine\". All fields are combined with a logical 'AND'." + fields: + Invoice: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_inc_input: + description: "input type for incrementing numeric columns in table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_insert_input: + description: "input type for inserting data into table \"InvoiceLine\"" + fields: + Invoice: + type: + type: nullable + underlying_type: + type: named + name: Invoice_obj_rel_insert_input + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_obj_rel_insert_input + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_max_fields: + description: aggregate max on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_max_order_by: + description: "order by max() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_min_fields: + description: aggregate min on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_min_order_by: + description: "order by min() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_mutation_response: + description: "response of any mutation on the table \"InvoiceLine\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: InvoiceLine + InvoiceLine_on_conflict: + description: "on_conflict condition type for table \"InvoiceLine\"" + fields: + constraint: + type: + type: named + name: InvoiceLine_constraint + update_columns: + type: + type: array + element_type: + type: named + name: InvoiceLine_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_order_by: + description: "Ordering options when selecting data from \"InvoiceLine\"." + fields: + Invoice: + type: + type: nullable + underlying_type: + type: named + name: Invoice_order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_pk_columns_input: + description: "primary key columns input for table: InvoiceLine" + fields: + InvoiceLineId: + type: + type: named + name: Int + InvoiceLine_set_input: + description: "input type for updating data in table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_stddev_fields: + description: aggregate stddev on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_stddev_order_by: + description: "order by stddev() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_stream_cursor_input: + description: "Streaming cursor of the table \"InvoiceLine\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: InvoiceLine_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + InvoiceLine_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_sum_fields: + description: aggregate sum on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_sum_order_by: + description: "order by sum() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_var_pop_fields: + description: aggregate var_pop on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_var_pop_order_by: + description: "order by var_pop() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_var_samp_fields: + description: aggregate var_samp on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_var_samp_order_by: + description: "order by var_samp() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_variance_fields: + description: aggregate variance on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_variance_order_by: + description: "order by variance() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_aggregate: + description: "aggregated selection of \"Invoice\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Invoice + Invoice_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_bool_exp_count + Invoice_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Invoice_aggregate_fields: + description: "aggregate fields of \"Invoice\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Invoice_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Invoice_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Invoice_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Invoice_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Invoice_variance_fields + Invoice_aggregate_order_by: + description: "order by aggregate values of table \"Invoice\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Invoice_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Invoice_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Invoice_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Invoice_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Invoice_variance_order_by + Invoice_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Invoice\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + Invoice_avg_fields: + description: aggregate avg on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_avg_order_by: + description: "order by avg() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_bool_exp: + description: "Boolean expression to filter rows from the table \"Invoice\". All fields are combined with a logical 'AND'." + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Customer: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp_comparison_exp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_bool_exp + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_bool_exp + Invoice_inc_input: + description: "input type for incrementing numeric columns in table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_insert_input: + description: "input type for inserting data into table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + Customer: + type: + type: nullable + underlying_type: + type: named + name: Customer_obj_rel_insert_input + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_arr_rel_insert_input + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_max_fields: + description: aggregate max on columns + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_max_order_by: + description: "order by max() on columns of table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingState: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_min_fields: + description: aggregate min on columns + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_min_order_by: + description: "order by min() on columns of table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingState: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_mutation_response: + description: "response of any mutation on the table \"Invoice\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Invoice + Invoice_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Invoice\"" + fields: + data: + type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + Invoice_on_conflict: + description: "on_conflict condition type for table \"Invoice\"" + fields: + constraint: + type: + type: named + name: Invoice_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Invoice_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoice_order_by: + description: "Ordering options when selecting data from \"Invoice\"." + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingState: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer: + type: + type: nullable + underlying_type: + type: named + name: Customer_order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_pk_columns_input: + description: "primary key columns input for table: Invoice" + fields: + InvoiceId: + type: + type: named + name: Int + Invoice_set_input: + description: "input type for updating data in table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_stddev_fields: + description: aggregate stddev on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_stddev_order_by: + description: "order by stddev() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_stream_cursor_input: + description: "Streaming cursor of the table \"Invoice\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Invoice_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Invoice_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_sum_fields: + description: aggregate sum on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_sum_order_by: + description: "order by sum() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Invoice_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Invoice_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Invoice_bool_exp + Invoice_var_pop_fields: + description: aggregate var_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_var_pop_order_by: + description: "order by var_pop() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_var_samp_fields: + description: aggregate var_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_var_samp_order_by: + description: "order by var_samp() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_variance_fields: + description: aggregate variance on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_variance_order_by: + description: "order by variance() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaType: + description: "columns and relationships of \"MediaType\"" + fields: + MediaTypeId: + type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + description: An aggregate relationship + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + MediaType_aggregate: + description: "aggregated selection of \"MediaType\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: MediaType_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: MediaType + MediaType_aggregate_fields: + description: "aggregate fields of \"MediaType\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: MediaType_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: MediaType_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: MediaType_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: MediaType_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: MediaType_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: MediaType_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: MediaType_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: MediaType_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: MediaType_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: MediaType_variance_fields + MediaType_avg_fields: + description: aggregate avg on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_bool_exp: + description: "Boolean expression to filter rows from the table \"MediaType\". All fields are combined with a logical 'AND'." + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_bool_exp + MediaType_insert_input: + description: "input type for inserting data into table \"MediaType\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_arr_rel_insert_input + MediaType_max_fields: + description: aggregate max on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_min_fields: + description: aggregate min on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_mutation_response: + description: "response of any mutation on the table \"MediaType\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: MediaType + MediaType_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"MediaType\"" + fields: + data: + type: + type: named + name: MediaType_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: MediaType_on_conflict + MediaType_on_conflict: + description: "on_conflict condition type for table \"MediaType\"" + fields: + constraint: + type: + type: named + name: MediaType_constraint + update_columns: + type: + type: array + element_type: + type: named + name: MediaType_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaType_order_by: + description: "Ordering options when selecting data from \"MediaType\"." + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_order_by + MediaType_pk_columns_input: + description: "primary key columns input for table: MediaType" + fields: + MediaTypeId: + type: + type: named + name: Int + MediaType_set_input: + description: "input type for updating data in table \"MediaType\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_stddev_fields: + description: aggregate stddev on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_stream_cursor_input: + description: "Streaming cursor of the table \"MediaType\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: MediaType_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + MediaType_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_sum_fields: + description: aggregate sum on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaType_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: MediaType_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: MediaType_bool_exp + MediaType_var_pop_fields: + description: aggregate var_pop on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_var_samp_fields: + description: aggregate var_samp on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_variance_fields: + description: aggregate variance on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist: + description: "columns and relationships of \"Playlist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: named + name: Int + PlaylistTracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + description: An aggregate relationship + type: + type: named + name: PlaylistTrack_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack: + description: "columns and relationships of \"PlaylistTrack\"" + fields: + Playlist: + description: An object relationship + type: + type: named + name: Playlist + PlaylistId: + type: + type: named + name: Int + Track: + description: An object relationship + type: + type: named + name: Track + TrackId: + type: + type: named + name: Int + PlaylistTrack_aggregate: + description: "aggregated selection of \"PlaylistTrack\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: PlaylistTrack + PlaylistTrack_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_bool_exp_count + PlaylistTrack_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + PlaylistTrack_aggregate_fields: + description: "aggregate fields of \"PlaylistTrack\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_variance_fields + PlaylistTrack_aggregate_order_by: + description: "order by aggregate values of table \"PlaylistTrack\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_variance_order_by + PlaylistTrack_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"PlaylistTrack\"" + fields: + data: + type: + type: array + element_type: + type: named + name: PlaylistTrack_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_on_conflict + PlaylistTrack_avg_fields: + description: aggregate avg on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_avg_order_by: + description: "order by avg() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_bool_exp: + description: "Boolean expression to filter rows from the table \"PlaylistTrack\". All fields are combined with a logical 'AND'." + fields: + Playlist: + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_inc_input: + description: "input type for incrementing numeric columns in table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_insert_input: + description: "input type for inserting data into table \"PlaylistTrack\"" + fields: + Playlist: + type: + type: nullable + underlying_type: + type: named + name: Playlist_obj_rel_insert_input + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_obj_rel_insert_input + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_max_fields: + description: aggregate max on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_max_order_by: + description: "order by max() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_min_fields: + description: aggregate min on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_min_order_by: + description: "order by min() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_mutation_response: + description: "response of any mutation on the table \"PlaylistTrack\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: PlaylistTrack + PlaylistTrack_on_conflict: + description: "on_conflict condition type for table \"PlaylistTrack\"" + fields: + constraint: + type: + type: named + name: PlaylistTrack_constraint + update_columns: + type: + type: array + element_type: + type: named + name: PlaylistTrack_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_order_by: + description: "Ordering options when selecting data from \"PlaylistTrack\"." + fields: + Playlist: + type: + type: nullable + underlying_type: + type: named + name: Playlist_order_by + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_pk_columns_input: + description: "primary key columns input for table: PlaylistTrack" + fields: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + PlaylistTrack_set_input: + description: "input type for updating data in table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_stddev_fields: + description: aggregate stddev on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_stddev_order_by: + description: "order by stddev() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_stream_cursor_input: + description: "Streaming cursor of the table \"PlaylistTrack\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: PlaylistTrack_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + PlaylistTrack_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_sum_fields: + description: aggregate sum on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_sum_order_by: + description: "order by sum() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_var_pop_fields: + description: aggregate var_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_var_pop_order_by: + description: "order by var_pop() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_var_samp_fields: + description: aggregate var_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_var_samp_order_by: + description: "order by var_samp() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_variance_fields: + description: aggregate variance on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_variance_order_by: + description: "order by variance() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Playlist_aggregate: + description: "aggregated selection of \"Playlist\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Playlist_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Playlist + Playlist_aggregate_fields: + description: "aggregate fields of \"Playlist\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Playlist_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Playlist_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Playlist_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Playlist_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Playlist_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Playlist_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Playlist_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Playlist_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Playlist_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Playlist_variance_fields + Playlist_avg_fields: + description: aggregate avg on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_bool_exp: + description: "Boolean expression to filter rows from the table \"Playlist\". All fields are combined with a logical 'AND'." + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_bool_exp + Playlist_insert_input: + description: "input type for inserting data into table \"Playlist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_arr_rel_insert_input + Playlist_max_fields: + description: aggregate max on columns + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_min_fields: + description: aggregate min on columns + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_mutation_response: + description: "response of any mutation on the table \"Playlist\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Playlist + Playlist_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Playlist\"" + fields: + data: + type: + type: named + name: Playlist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Playlist_on_conflict + Playlist_on_conflict: + description: "on_conflict condition type for table \"Playlist\"" + fields: + constraint: + type: + type: named + name: Playlist_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Playlist_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + Playlist_order_by: + description: "Ordering options when selecting data from \"Playlist\"." + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_order_by + Playlist_pk_columns_input: + description: "primary key columns input for table: Playlist" + fields: + PlaylistId: + type: + type: named + name: Int + Playlist_set_input: + description: "input type for updating data in table \"Playlist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Playlist_stddev_fields: + description: aggregate stddev on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_stream_cursor_input: + description: "Streaming cursor of the table \"Playlist\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Playlist_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Playlist_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_sum_fields: + description: aggregate sum on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Playlist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Playlist_bool_exp + Playlist_var_pop_fields: + description: aggregate var_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_var_samp_fields: + description: aggregate var_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_variance_fields: + description: aggregate variance on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + String_comparison_exp: + description: "Boolean expression to compare columns of type \"String\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: String + _gt: + type: + type: nullable + underlying_type: + type: named + name: String + _gte: + type: + type: nullable + underlying_type: + type: named + name: String + _ilike: + description: does the column match the given case-insensitive pattern + type: + type: nullable + underlying_type: + type: named + name: String + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: String + _iregex: + description: "does the column match the given POSIX regular expression, case insensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _like: + description: does the column match the given pattern + type: + type: nullable + underlying_type: + type: named + name: String + _lt: + type: + type: nullable + underlying_type: + type: named + name: String + _lte: + type: + type: nullable + underlying_type: + type: named + name: String + _neq: + type: + type: nullable + underlying_type: + type: named + name: String + _nilike: + description: does the column NOT match the given case-insensitive pattern + type: + type: nullable + underlying_type: + type: named + name: String + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: String + _niregex: + description: "does the column NOT match the given POSIX regular expression, case insensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _nlike: + description: does the column NOT match the given pattern + type: + type: nullable + underlying_type: + type: named + name: String + _nregex: + description: "does the column NOT match the given POSIX regular expression, case sensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _nsimilar: + description: does the column NOT match the given SQL regular expression + type: + type: nullable + underlying_type: + type: named + name: String + _regex: + description: "does the column match the given POSIX regular expression, case sensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _similar: + description: does the column match the given SQL regular expression + type: + type: nullable + underlying_type: + type: named + name: String + Track: + description: "columns and relationships of \"Track\"" + fields: + Album: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Album + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + Genre: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Genre + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLines: + description: An array relationship + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + description: An aggregate relationship + type: + type: named + name: InvoiceLine_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + MediaType: + description: An object relationship + type: + type: named + name: MediaType + MediaTypeId: + type: + type: named + name: Int + Milliseconds: + type: + type: named + name: Int + Name: + type: + type: named + name: String + PlaylistTracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + description: An aggregate relationship + type: + type: named + name: PlaylistTrack_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + TrackId: + type: + type: named + name: Int + UnitPrice: + type: + type: named + name: numeric + Track_aggregate: + description: "aggregated selection of \"Track\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Track + Track_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp_count + Track_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Track_aggregate_fields: + description: "aggregate fields of \"Track\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Track_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Track_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Track_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Track_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Track_variance_fields + Track_aggregate_order_by: + description: "order by aggregate values of table \"Track\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Track_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Track_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Track_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Track_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Track_variance_order_by + Track_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Track\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + Track_avg_fields: + description: aggregate avg on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_avg_order_by: + description: "order by avg() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_bool_exp: + description: "Boolean expression to filter rows from the table \"Track\". All fields are combined with a logical 'AND'." + fields: + Album: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Composer: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Genre: + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_bool_exp + MediaType: + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_bool_exp + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_bool_exp + Track_inc_input: + description: "input type for incrementing numeric columns in table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_insert_input: + description: "input type for inserting data into table \"Track\"" + fields: + Album: + type: + type: nullable + underlying_type: + type: named + name: Album_obj_rel_insert_input + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + Genre: + type: + type: nullable + underlying_type: + type: named + name: Genre_obj_rel_insert_input + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_arr_rel_insert_input + MediaType: + type: + type: nullable + underlying_type: + type: named + name: MediaType_obj_rel_insert_input + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_arr_rel_insert_input + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_max_fields: + description: aggregate max on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_max_order_by: + description: "order by max() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + Composer: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_min_fields: + description: aggregate min on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_min_order_by: + description: "order by min() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + Composer: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_mutation_response: + description: "response of any mutation on the table \"Track\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Track + Track_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Track\"" + fields: + data: + type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + Track_on_conflict: + description: "on_conflict condition type for table \"Track\"" + fields: + constraint: + type: + type: named + name: Track_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Track_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Track_order_by: + description: "Ordering options when selecting data from \"Track\"." + fields: + Album: + type: + type: nullable + underlying_type: + type: named + name: Album_order_by + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + Composer: + type: + type: nullable + underlying_type: + type: named + name: order_by + Genre: + type: + type: nullable + underlying_type: + type: named + name: Genre_order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_order_by + MediaType: + type: + type: nullable + underlying_type: + type: named + name: MediaType_order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_pk_columns_input: + description: "primary key columns input for table: Track" + fields: + TrackId: + type: + type: named + name: Int + Track_set_input: + description: "input type for updating data in table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_stddev_fields: + description: aggregate stddev on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_stddev_order_by: + description: "order by stddev() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_stream_cursor_input: + description: "Streaming cursor of the table \"Track\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Track_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Track_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_sum_fields: + description: aggregate sum on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_sum_order_by: + description: "order by sum() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Track_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Track_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Track_bool_exp + Track_var_pop_fields: + description: aggregate var_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_var_pop_order_by: + description: "order by var_pop() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_var_samp_fields: + description: aggregate var_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_var_samp_order_by: + description: "order by var_samp() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_variance_fields: + description: aggregate variance on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_variance_order_by: + description: "order by variance() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + _AlbumQueryResponse: + description: Response type for function Album + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Album + _Album_aggregateQueryResponse: + description: Response type for function Album_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Album_aggregate + _Album_by_pkQueryResponse: + description: Response type for function Album_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album + _ArtistQueryResponse: + description: Response type for function Artist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Artist + _Artist_aggregateQueryResponse: + description: Response type for function Artist_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Artist_aggregate + _Artist_by_pkQueryResponse: + description: Response type for function Artist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist + _CustomerQueryResponse: + description: Response type for function Customer + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Customer + _Customer_aggregateQueryResponse: + description: Response type for function Customer_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Customer_aggregate + _Customer_by_pkQueryResponse: + description: Response type for function Customer_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer + _EmployeeQueryResponse: + description: Response type for function Employee + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Employee + _Employee_aggregateQueryResponse: + description: Response type for function Employee_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Employee_aggregate + _Employee_by_pkQueryResponse: + description: Response type for function Employee_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee + _GenreQueryResponse: + description: Response type for function Genre + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Genre + _Genre_aggregateQueryResponse: + description: Response type for function Genre_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Genre_aggregate + _Genre_by_pkQueryResponse: + description: Response type for function Genre_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre + _InvoiceLineQueryResponse: + description: Response type for function InvoiceLine + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: InvoiceLine + _InvoiceLine_aggregateQueryResponse: + description: Response type for function InvoiceLine_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: InvoiceLine_aggregate + _InvoiceLine_by_pkQueryResponse: + description: Response type for function InvoiceLine_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + _InvoiceQueryResponse: + description: Response type for function Invoice + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Invoice + _Invoice_aggregateQueryResponse: + description: Response type for function Invoice_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Invoice_aggregate + _Invoice_by_pkQueryResponse: + description: Response type for function Invoice_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice + _MediaTypeQueryResponse: + description: Response type for function MediaType + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: MediaType + _MediaType_aggregateQueryResponse: + description: Response type for function MediaType_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: MediaType_aggregate + _MediaType_by_pkQueryResponse: + description: Response type for function MediaType_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType + _PlaylistQueryResponse: + description: Response type for function Playlist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Playlist + _PlaylistTrackQueryResponse: + description: Response type for function PlaylistTrack + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: PlaylistTrack + _PlaylistTrack_aggregateQueryResponse: + description: Response type for function PlaylistTrack_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: PlaylistTrack_aggregate + _PlaylistTrack_by_pkQueryResponse: + description: Response type for function PlaylistTrack_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + _Playlist_aggregateQueryResponse: + description: Response type for function Playlist_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Playlist_aggregate + _Playlist_by_pkQueryResponse: + description: Response type for function Playlist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist + _TrackQueryResponse: + description: Response type for function Track + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Track + _Track_aggregateQueryResponse: + description: Response type for function Track_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Track_aggregate + _Track_by_pkQueryResponse: + description: Response type for function Track_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track + _delete_AlbumMutationResponse: + description: Response type for procedure delete_Album + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + _delete_Album_by_pkMutationResponse: + description: Response type for procedure delete_Album_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album + _delete_ArtistMutationResponse: + description: Response type for procedure delete_Artist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + _delete_Artist_by_pkMutationResponse: + description: Response type for procedure delete_Artist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist + _delete_CustomerMutationResponse: + description: Response type for procedure delete_Customer + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + _delete_Customer_by_pkMutationResponse: + description: Response type for procedure delete_Customer_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer + _delete_EmployeeMutationResponse: + description: Response type for procedure delete_Employee + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + _delete_Employee_by_pkMutationResponse: + description: Response type for procedure delete_Employee_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee + _delete_GenreMutationResponse: + description: Response type for procedure delete_Genre + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + _delete_Genre_by_pkMutationResponse: + description: Response type for procedure delete_Genre_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre + _delete_InvoiceLineMutationResponse: + description: Response type for procedure delete_InvoiceLine + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + _delete_InvoiceLine_by_pkMutationResponse: + description: Response type for procedure delete_InvoiceLine_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + _delete_InvoiceMutationResponse: + description: Response type for procedure delete_Invoice + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + _delete_Invoice_by_pkMutationResponse: + description: Response type for procedure delete_Invoice_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice + _delete_MediaTypeMutationResponse: + description: Response type for procedure delete_MediaType + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + _delete_MediaType_by_pkMutationResponse: + description: Response type for procedure delete_MediaType_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType + _delete_PlaylistMutationResponse: + description: Response type for procedure delete_Playlist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + _delete_PlaylistTrackMutationResponse: + description: Response type for procedure delete_PlaylistTrack + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + _delete_PlaylistTrack_by_pkMutationResponse: + description: Response type for procedure delete_PlaylistTrack_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + _delete_Playlist_by_pkMutationResponse: + description: Response type for procedure delete_Playlist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist + _delete_TrackMutationResponse: + description: Response type for procedure delete_Track + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + _delete_Track_by_pkMutationResponse: + description: Response type for procedure delete_Track_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track + _insert_AlbumMutationResponse: + description: Response type for procedure insert_Album + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + _insert_Album_oneMutationResponse: + description: Response type for procedure insert_Album_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album + _insert_ArtistMutationResponse: + description: Response type for procedure insert_Artist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + _insert_Artist_oneMutationResponse: + description: Response type for procedure insert_Artist_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist + _insert_CustomerMutationResponse: + description: Response type for procedure insert_Customer + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + _insert_Customer_oneMutationResponse: + description: Response type for procedure insert_Customer_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer + _insert_EmployeeMutationResponse: + description: Response type for procedure insert_Employee + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + _insert_Employee_oneMutationResponse: + description: Response type for procedure insert_Employee_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee + _insert_GenreMutationResponse: + description: Response type for procedure insert_Genre + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + _insert_Genre_oneMutationResponse: + description: Response type for procedure insert_Genre_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre + _insert_InvoiceLineMutationResponse: + description: Response type for procedure insert_InvoiceLine + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + _insert_InvoiceLine_oneMutationResponse: + description: Response type for procedure insert_InvoiceLine_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + _insert_InvoiceMutationResponse: + description: Response type for procedure insert_Invoice + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + _insert_Invoice_oneMutationResponse: + description: Response type for procedure insert_Invoice_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice + _insert_MediaTypeMutationResponse: + description: Response type for procedure insert_MediaType + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + _insert_MediaType_oneMutationResponse: + description: Response type for procedure insert_MediaType_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType + _insert_PlaylistMutationResponse: + description: Response type for procedure insert_Playlist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + _insert_PlaylistTrackMutationResponse: + description: Response type for procedure insert_PlaylistTrack + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + _insert_PlaylistTrack_oneMutationResponse: + description: Response type for procedure insert_PlaylistTrack_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + _insert_Playlist_oneMutationResponse: + description: Response type for procedure insert_Playlist_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist + _insert_TrackMutationResponse: + description: Response type for procedure insert_Track + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + _insert_Track_oneMutationResponse: + description: Response type for procedure insert_Track_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track + _update_AlbumMutationResponse: + description: Response type for procedure update_Album + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + _update_Album_by_pkMutationResponse: + description: Response type for procedure update_Album_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album + _update_Album_manyMutationResponse: + description: Response type for procedure update_Album_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + _update_ArtistMutationResponse: + description: Response type for procedure update_Artist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + _update_Artist_by_pkMutationResponse: + description: Response type for procedure update_Artist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist + _update_Artist_manyMutationResponse: + description: Response type for procedure update_Artist_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + _update_CustomerMutationResponse: + description: Response type for procedure update_Customer + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + _update_Customer_by_pkMutationResponse: + description: Response type for procedure update_Customer_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer + _update_Customer_manyMutationResponse: + description: Response type for procedure update_Customer_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + _update_EmployeeMutationResponse: + description: Response type for procedure update_Employee + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + _update_Employee_by_pkMutationResponse: + description: Response type for procedure update_Employee_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee + _update_Employee_manyMutationResponse: + description: Response type for procedure update_Employee_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + _update_GenreMutationResponse: + description: Response type for procedure update_Genre + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + _update_Genre_by_pkMutationResponse: + description: Response type for procedure update_Genre_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre + _update_Genre_manyMutationResponse: + description: Response type for procedure update_Genre_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + _update_InvoiceLineMutationResponse: + description: Response type for procedure update_InvoiceLine + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + _update_InvoiceLine_by_pkMutationResponse: + description: Response type for procedure update_InvoiceLine_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + _update_InvoiceLine_manyMutationResponse: + description: Response type for procedure update_InvoiceLine_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + _update_InvoiceMutationResponse: + description: Response type for procedure update_Invoice + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + _update_Invoice_by_pkMutationResponse: + description: Response type for procedure update_Invoice_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice + _update_Invoice_manyMutationResponse: + description: Response type for procedure update_Invoice_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + _update_MediaTypeMutationResponse: + description: Response type for procedure update_MediaType + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + _update_MediaType_by_pkMutationResponse: + description: Response type for procedure update_MediaType_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType + _update_MediaType_manyMutationResponse: + description: Response type for procedure update_MediaType_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + _update_PlaylistMutationResponse: + description: Response type for procedure update_Playlist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + _update_PlaylistTrackMutationResponse: + description: Response type for procedure update_PlaylistTrack + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + _update_PlaylistTrack_by_pkMutationResponse: + description: Response type for procedure update_PlaylistTrack_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + _update_PlaylistTrack_manyMutationResponse: + description: Response type for procedure update_PlaylistTrack_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + _update_Playlist_by_pkMutationResponse: + description: Response type for procedure update_Playlist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist + _update_Playlist_manyMutationResponse: + description: Response type for procedure update_Playlist_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + _update_TrackMutationResponse: + description: Response type for procedure update_Track + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + _update_Track_by_pkMutationResponse: + description: Response type for procedure update_Track_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track + _update_Track_manyMutationResponse: + description: Response type for procedure update_Track_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + numeric_comparison_exp: + description: "Boolean expression to compare columns of type \"numeric\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: numeric + _gt: + type: + type: nullable + underlying_type: + type: named + name: numeric + _gte: + type: + type: nullable + underlying_type: + type: named + name: numeric + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: numeric + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _lt: + type: + type: nullable + underlying_type: + type: named + name: numeric + _lte: + type: + type: nullable + underlying_type: + type: named + name: numeric + _neq: + type: + type: nullable + underlying_type: + type: named + name: numeric + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: numeric + subscription_root: + fields: + Album: + description: "fetch data from the table: \"Album\"" + type: + type: array + element_type: + type: named + name: Album + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Album_aggregate: + description: "fetch aggregated fields from the table: \"Album\"" + type: + type: named + name: Album_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Album_by_pk: + description: "fetch data from the table: \"Album\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Album + arguments: + AlbumId: + type: + type: named + name: Int + Album_stream: + description: "fetch data from the table in a streaming manner: \"Album\"" + type: + type: array + element_type: + type: named + name: Album + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Album_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Artist: + description: "fetch data from the table: \"Artist\"" + type: + type: array + element_type: + type: named + name: Artist + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Artist_aggregate: + description: "fetch aggregated fields from the table: \"Artist\"" + type: + type: named + name: Artist_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Artist_by_pk: + description: "fetch data from the table: \"Artist\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Artist + arguments: + ArtistId: + type: + type: named + name: Int + Artist_stream: + description: "fetch data from the table in a streaming manner: \"Artist\"" + type: + type: array + element_type: + type: named + name: Artist + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Artist_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Customer: + description: "fetch data from the table: \"Customer\"" + type: + type: array + element_type: + type: named + name: Customer + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customer_aggregate: + description: "fetch aggregated fields from the table: \"Customer\"" + type: + type: named + name: Customer_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customer_by_pk: + description: "fetch data from the table: \"Customer\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Customer + arguments: + CustomerId: + type: + type: named + name: Int + Customer_stream: + description: "fetch data from the table in a streaming manner: \"Customer\"" + type: + type: array + element_type: + type: named + name: Customer + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Customer_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Employee: + description: "fetch data from the table: \"Employee\"" + type: + type: array + element_type: + type: named + name: Employee + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employee_aggregate: + description: "fetch aggregated fields from the table: \"Employee\"" + type: + type: named + name: Employee_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employee_by_pk: + description: "fetch data from the table: \"Employee\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Employee + arguments: + EmployeeId: + type: + type: named + name: Int + Employee_stream: + description: "fetch data from the table in a streaming manner: \"Employee\"" + type: + type: array + element_type: + type: named + name: Employee + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Employee_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Genre: + description: "fetch data from the table: \"Genre\"" + type: + type: array + element_type: + type: named + name: Genre + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Genre_aggregate: + description: "fetch aggregated fields from the table: \"Genre\"" + type: + type: named + name: Genre_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Genre_by_pk: + description: "fetch data from the table: \"Genre\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Genre + arguments: + GenreId: + type: + type: named + name: Int + Genre_stream: + description: "fetch data from the table in a streaming manner: \"Genre\"" + type: + type: array + element_type: + type: named + name: Genre + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Genre_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Invoice: + description: "fetch data from the table: \"Invoice\"" + type: + type: array + element_type: + type: named + name: Invoice + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + InvoiceLine: + description: "fetch data from the table: \"InvoiceLine\"" + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_aggregate: + description: "fetch aggregated fields from the table: \"InvoiceLine\"" + type: + type: named + name: InvoiceLine_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_by_pk: + description: "fetch data from the table: \"InvoiceLine\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + arguments: + InvoiceLineId: + type: + type: named + name: Int + InvoiceLine_stream: + description: "fetch data from the table in a streaming manner: \"InvoiceLine\"" + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + Invoice_aggregate: + description: "fetch aggregated fields from the table: \"Invoice\"" + type: + type: named + name: Invoice_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoice_by_pk: + description: "fetch data from the table: \"Invoice\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Invoice + arguments: + InvoiceId: + type: + type: named + name: Int + Invoice_stream: + description: "fetch data from the table in a streaming manner: \"Invoice\"" + type: + type: array + element_type: + type: named + name: Invoice + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Invoice_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + MediaType: + description: "fetch data from the table: \"MediaType\"" + type: + type: array + element_type: + type: named + name: MediaType + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaType_aggregate: + description: "fetch aggregated fields from the table: \"MediaType\"" + type: + type: named + name: MediaType_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaType_by_pk: + description: "fetch data from the table: \"MediaType\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: MediaType + arguments: + MediaTypeId: + type: + type: named + name: Int + MediaType_stream: + description: "fetch data from the table in a streaming manner: \"MediaType\"" + type: + type: array + element_type: + type: named + name: MediaType + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: MediaType_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + Playlist: + description: "fetch data from the table: \"Playlist\"" + type: + type: array + element_type: + type: named + name: Playlist + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + PlaylistTrack: + description: "fetch data from the table: \"PlaylistTrack\"" + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_aggregate: + description: "fetch aggregated fields from the table: \"PlaylistTrack\"" + type: + type: named + name: PlaylistTrack_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_by_pk: + description: "fetch data from the table: \"PlaylistTrack\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + arguments: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + PlaylistTrack_stream: + description: "fetch data from the table in a streaming manner: \"PlaylistTrack\"" + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + Playlist_aggregate: + description: "fetch aggregated fields from the table: \"Playlist\"" + type: + type: named + name: Playlist_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + Playlist_by_pk: + description: "fetch data from the table: \"Playlist\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Playlist + arguments: + PlaylistId: + type: + type: named + name: Int + Playlist_stream: + description: "fetch data from the table in a streaming manner: \"Playlist\"" + type: + type: array + element_type: + type: named + name: Playlist + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Playlist_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + Track: + description: "fetch data from the table: \"Track\"" + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Track_aggregate: + description: "fetch aggregated fields from the table: \"Track\"" + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Track_by_pk: + description: "fetch data from the table: \"Track\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Track + arguments: + TrackId: + type: + type: named + name: Int + Track_stream: + description: "fetch data from the table in a streaming manner: \"Track\"" + type: + type: array + element_type: + type: named + name: Track + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Track_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + timestamp_comparison_exp: + description: "Boolean expression to compare columns of type \"timestamp\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _gt: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _gte: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: timestamp + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _lt: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _lte: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _neq: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: timestamp +collections: [] +functions: + - name: Album + description: "fetch data from the table: \"Album\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + result_type: + type: named + name: _AlbumQueryResponse + - name: Album_aggregate + description: "fetch aggregated fields from the table: \"Album\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + result_type: + type: named + name: _Album_aggregateQueryResponse + - name: Album_by_pk + description: "fetch data from the table: \"Album\" using primary key columns" + arguments: + AlbumId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Album_by_pkQueryResponse + - name: Artist + description: "fetch data from the table: \"Artist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + result_type: + type: named + name: _ArtistQueryResponse + - name: Artist_aggregate + description: "fetch aggregated fields from the table: \"Artist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + result_type: + type: named + name: _Artist_aggregateQueryResponse + - name: Artist_by_pk + description: "fetch data from the table: \"Artist\" using primary key columns" + arguments: + ArtistId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Artist_by_pkQueryResponse + - name: Customer + description: "fetch data from the table: \"Customer\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + result_type: + type: named + name: _CustomerQueryResponse + - name: Customer_aggregate + description: "fetch aggregated fields from the table: \"Customer\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + result_type: + type: named + name: _Customer_aggregateQueryResponse + - name: Customer_by_pk + description: "fetch data from the table: \"Customer\" using primary key columns" + arguments: + CustomerId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Customer_by_pkQueryResponse + - name: Employee + description: "fetch data from the table: \"Employee\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + result_type: + type: named + name: _EmployeeQueryResponse + - name: Employee_aggregate + description: "fetch aggregated fields from the table: \"Employee\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + result_type: + type: named + name: _Employee_aggregateQueryResponse + - name: Employee_by_pk + description: "fetch data from the table: \"Employee\" using primary key columns" + arguments: + EmployeeId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Employee_by_pkQueryResponse + - name: Genre + description: "fetch data from the table: \"Genre\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + result_type: + type: named + name: _GenreQueryResponse + - name: Genre_aggregate + description: "fetch aggregated fields from the table: \"Genre\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + result_type: + type: named + name: _Genre_aggregateQueryResponse + - name: Genre_by_pk + description: "fetch data from the table: \"Genre\" using primary key columns" + arguments: + GenreId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Genre_by_pkQueryResponse + - name: Invoice + description: "fetch data from the table: \"Invoice\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + result_type: + type: named + name: _InvoiceQueryResponse + - name: InvoiceLine + description: "fetch data from the table: \"InvoiceLine\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: named + name: _InvoiceLineQueryResponse + - name: InvoiceLine_aggregate + description: "fetch aggregated fields from the table: \"InvoiceLine\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: named + name: _InvoiceLine_aggregateQueryResponse + - name: InvoiceLine_by_pk + description: "fetch data from the table: \"InvoiceLine\" using primary key columns" + arguments: + InvoiceLineId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _InvoiceLine_by_pkQueryResponse + - name: Invoice_aggregate + description: "fetch aggregated fields from the table: \"Invoice\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + result_type: + type: named + name: _Invoice_aggregateQueryResponse + - name: Invoice_by_pk + description: "fetch data from the table: \"Invoice\" using primary key columns" + arguments: + InvoiceId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Invoice_by_pkQueryResponse + - name: MediaType + description: "fetch data from the table: \"MediaType\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + result_type: + type: named + name: _MediaTypeQueryResponse + - name: MediaType_aggregate + description: "fetch aggregated fields from the table: \"MediaType\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + result_type: + type: named + name: _MediaType_aggregateQueryResponse + - name: MediaType_by_pk + description: "fetch data from the table: \"MediaType\" using primary key columns" + arguments: + MediaTypeId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _MediaType_by_pkQueryResponse + - name: Playlist + description: "fetch data from the table: \"Playlist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + result_type: + type: named + name: _PlaylistQueryResponse + - name: PlaylistTrack + description: "fetch data from the table: \"PlaylistTrack\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: named + name: _PlaylistTrackQueryResponse + - name: PlaylistTrack_aggregate + description: "fetch aggregated fields from the table: \"PlaylistTrack\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: named + name: _PlaylistTrack_aggregateQueryResponse + - name: PlaylistTrack_by_pk + description: "fetch data from the table: \"PlaylistTrack\" using primary key columns" + arguments: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _PlaylistTrack_by_pkQueryResponse + - name: Playlist_aggregate + description: "fetch aggregated fields from the table: \"Playlist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + result_type: + type: named + name: _Playlist_aggregateQueryResponse + - name: Playlist_by_pk + description: "fetch data from the table: \"Playlist\" using primary key columns" + arguments: + PlaylistId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Playlist_by_pkQueryResponse + - name: Track + description: "fetch data from the table: \"Track\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + result_type: + type: named + name: _TrackQueryResponse + - name: Track_aggregate + description: "fetch aggregated fields from the table: \"Track\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + result_type: + type: named + name: _Track_aggregateQueryResponse + - name: Track_by_pk + description: "fetch data from the table: \"Track\" using primary key columns" + arguments: + TrackId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Track_by_pkQueryResponse +procedures: + - name: delete_Album + description: "delete data from the table: \"Album\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Album_bool_exp + result_type: + type: named + name: _delete_AlbumMutationResponse + - name: delete_Album_by_pk + description: "delete single row from the table: \"Album\"" + arguments: + AlbumId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Album_by_pkMutationResponse + - name: delete_Artist + description: "delete data from the table: \"Artist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Artist_bool_exp + result_type: + type: named + name: _delete_ArtistMutationResponse + - name: delete_Artist_by_pk + description: "delete single row from the table: \"Artist\"" + arguments: + ArtistId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Artist_by_pkMutationResponse + - name: delete_Customer + description: "delete data from the table: \"Customer\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Customer_bool_exp + result_type: + type: named + name: _delete_CustomerMutationResponse + - name: delete_Customer_by_pk + description: "delete single row from the table: \"Customer\"" + arguments: + CustomerId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Customer_by_pkMutationResponse + - name: delete_Employee + description: "delete data from the table: \"Employee\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Employee_bool_exp + result_type: + type: named + name: _delete_EmployeeMutationResponse + - name: delete_Employee_by_pk + description: "delete single row from the table: \"Employee\"" + arguments: + EmployeeId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Employee_by_pkMutationResponse + - name: delete_Genre + description: "delete data from the table: \"Genre\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Genre_bool_exp + result_type: + type: named + name: _delete_GenreMutationResponse + - name: delete_Genre_by_pk + description: "delete single row from the table: \"Genre\"" + arguments: + GenreId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Genre_by_pkMutationResponse + - name: delete_Invoice + description: "delete data from the table: \"Invoice\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Invoice_bool_exp + result_type: + type: named + name: _delete_InvoiceMutationResponse + - name: delete_InvoiceLine + description: "delete data from the table: \"InvoiceLine\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: named + name: _delete_InvoiceLineMutationResponse + - name: delete_InvoiceLine_by_pk + description: "delete single row from the table: \"InvoiceLine\"" + arguments: + InvoiceLineId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_InvoiceLine_by_pkMutationResponse + - name: delete_Invoice_by_pk + description: "delete single row from the table: \"Invoice\"" + arguments: + InvoiceId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Invoice_by_pkMutationResponse + - name: delete_MediaType + description: "delete data from the table: \"MediaType\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: MediaType_bool_exp + result_type: + type: named + name: _delete_MediaTypeMutationResponse + - name: delete_MediaType_by_pk + description: "delete single row from the table: \"MediaType\"" + arguments: + MediaTypeId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_MediaType_by_pkMutationResponse + - name: delete_Playlist + description: "delete data from the table: \"Playlist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Playlist_bool_exp + result_type: + type: named + name: _delete_PlaylistMutationResponse + - name: delete_PlaylistTrack + description: "delete data from the table: \"PlaylistTrack\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: named + name: _delete_PlaylistTrackMutationResponse + - name: delete_PlaylistTrack_by_pk + description: "delete single row from the table: \"PlaylistTrack\"" + arguments: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_PlaylistTrack_by_pkMutationResponse + - name: delete_Playlist_by_pk + description: "delete single row from the table: \"Playlist\"" + arguments: + PlaylistId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Playlist_by_pkMutationResponse + - name: delete_Track + description: "delete data from the table: \"Track\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Track_bool_exp + result_type: + type: named + name: _delete_TrackMutationResponse + - name: delete_Track_by_pk + description: "delete single row from the table: \"Track\"" + arguments: + TrackId: + type: + type: named + name: Int + _headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Track_by_pkMutationResponse + - name: insert_Album + description: "insert data into the table: \"Album\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + result_type: + type: named + name: _insert_AlbumMutationResponse + - name: insert_Album_one + description: "insert a single row into the table: \"Album\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + result_type: + type: named + name: _insert_Album_oneMutationResponse + - name: insert_Artist + description: "insert data into the table: \"Artist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Artist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Artist_on_conflict + result_type: + type: named + name: _insert_ArtistMutationResponse + - name: insert_Artist_one + description: "insert a single row into the table: \"Artist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Artist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Artist_on_conflict + result_type: + type: named + name: _insert_Artist_oneMutationResponse + - name: insert_Customer + description: "insert data into the table: \"Customer\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + result_type: + type: named + name: _insert_CustomerMutationResponse + - name: insert_Customer_one + description: "insert a single row into the table: \"Customer\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + result_type: + type: named + name: _insert_Customer_oneMutationResponse + - name: insert_Employee + description: "insert data into the table: \"Employee\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + result_type: + type: named + name: _insert_EmployeeMutationResponse + - name: insert_Employee_one + description: "insert a single row into the table: \"Employee\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + result_type: + type: named + name: _insert_Employee_oneMutationResponse + - name: insert_Genre + description: "insert data into the table: \"Genre\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Genre_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Genre_on_conflict + result_type: + type: named + name: _insert_GenreMutationResponse + - name: insert_Genre_one + description: "insert a single row into the table: \"Genre\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Genre_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Genre_on_conflict + result_type: + type: named + name: _insert_Genre_oneMutationResponse + - name: insert_Invoice + description: "insert data into the table: \"Invoice\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + result_type: + type: named + name: _insert_InvoiceMutationResponse + - name: insert_InvoiceLine + description: "insert data into the table: \"InvoiceLine\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: InvoiceLine_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_on_conflict + result_type: + type: named + name: _insert_InvoiceLineMutationResponse + - name: insert_InvoiceLine_one + description: "insert a single row into the table: \"InvoiceLine\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: InvoiceLine_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_on_conflict + result_type: + type: named + name: _insert_InvoiceLine_oneMutationResponse + - name: insert_Invoice_one + description: "insert a single row into the table: \"Invoice\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + result_type: + type: named + name: _insert_Invoice_oneMutationResponse + - name: insert_MediaType + description: "insert data into the table: \"MediaType\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: MediaType_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: MediaType_on_conflict + result_type: + type: named + name: _insert_MediaTypeMutationResponse + - name: insert_MediaType_one + description: "insert a single row into the table: \"MediaType\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: MediaType_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: MediaType_on_conflict + result_type: + type: named + name: _insert_MediaType_oneMutationResponse + - name: insert_Playlist + description: "insert data into the table: \"Playlist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Playlist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Playlist_on_conflict + result_type: + type: named + name: _insert_PlaylistMutationResponse + - name: insert_PlaylistTrack + description: "insert data into the table: \"PlaylistTrack\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: PlaylistTrack_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_on_conflict + result_type: + type: named + name: _insert_PlaylistTrackMutationResponse + - name: insert_PlaylistTrack_one + description: "insert a single row into the table: \"PlaylistTrack\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: PlaylistTrack_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_on_conflict + result_type: + type: named + name: _insert_PlaylistTrack_oneMutationResponse + - name: insert_Playlist_one + description: "insert a single row into the table: \"Playlist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Playlist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Playlist_on_conflict + result_type: + type: named + name: _insert_Playlist_oneMutationResponse + - name: insert_Track + description: "insert data into the table: \"Track\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + result_type: + type: named + name: _insert_TrackMutationResponse + - name: insert_Track_one + description: "insert a single row into the table: \"Track\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + result_type: + type: named + name: _insert_Track_oneMutationResponse + - name: update_Album + description: "update data of the table: \"Album\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Album_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Album_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Album_bool_exp + result_type: + type: named + name: _update_AlbumMutationResponse + - name: update_Album_by_pk + description: "update single row of the table: \"Album\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Album_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Album_set_input + pk_columns: + type: + type: named + name: Album_pk_columns_input + result_type: + type: named + name: _update_Album_by_pkMutationResponse + - name: update_Album_many + description: "update multiples rows of table: \"Album\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Album_updates + result_type: + type: named + name: _update_Album_manyMutationResponse + - name: update_Artist + description: "update data of the table: \"Artist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Artist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Artist_bool_exp + result_type: + type: named + name: _update_ArtistMutationResponse + - name: update_Artist_by_pk + description: "update single row of the table: \"Artist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Artist_set_input + pk_columns: + type: + type: named + name: Artist_pk_columns_input + result_type: + type: named + name: _update_Artist_by_pkMutationResponse + - name: update_Artist_many + description: "update multiples rows of table: \"Artist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Artist_updates + result_type: + type: named + name: _update_Artist_manyMutationResponse + - name: update_Customer + description: "update data of the table: \"Customer\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Customer_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Customer_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Customer_bool_exp + result_type: + type: named + name: _update_CustomerMutationResponse + - name: update_Customer_by_pk + description: "update single row of the table: \"Customer\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Customer_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Customer_set_input + pk_columns: + type: + type: named + name: Customer_pk_columns_input + result_type: + type: named + name: _update_Customer_by_pkMutationResponse + - name: update_Customer_many + description: "update multiples rows of table: \"Customer\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Customer_updates + result_type: + type: named + name: _update_Customer_manyMutationResponse + - name: update_Employee + description: "update data of the table: \"Employee\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Employee_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Employee_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Employee_bool_exp + result_type: + type: named + name: _update_EmployeeMutationResponse + - name: update_Employee_by_pk + description: "update single row of the table: \"Employee\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Employee_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Employee_set_input + pk_columns: + type: + type: named + name: Employee_pk_columns_input + result_type: + type: named + name: _update_Employee_by_pkMutationResponse + - name: update_Employee_many + description: "update multiples rows of table: \"Employee\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Employee_updates + result_type: + type: named + name: _update_Employee_manyMutationResponse + - name: update_Genre + description: "update data of the table: \"Genre\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Genre_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Genre_bool_exp + result_type: + type: named + name: _update_GenreMutationResponse + - name: update_Genre_by_pk + description: "update single row of the table: \"Genre\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Genre_set_input + pk_columns: + type: + type: named + name: Genre_pk_columns_input + result_type: + type: named + name: _update_Genre_by_pkMutationResponse + - name: update_Genre_many + description: "update multiples rows of table: \"Genre\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Genre_updates + result_type: + type: named + name: _update_Genre_manyMutationResponse + - name: update_Invoice + description: "update data of the table: \"Invoice\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Invoice_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Invoice_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Invoice_bool_exp + result_type: + type: named + name: _update_InvoiceMutationResponse + - name: update_InvoiceLine + description: "update data of the table: \"InvoiceLine\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: named + name: _update_InvoiceLineMutationResponse + - name: update_InvoiceLine_by_pk + description: "update single row of the table: \"InvoiceLine\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_set_input + pk_columns: + type: + type: named + name: InvoiceLine_pk_columns_input + result_type: + type: named + name: _update_InvoiceLine_by_pkMutationResponse + - name: update_InvoiceLine_many + description: "update multiples rows of table: \"InvoiceLine\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: InvoiceLine_updates + result_type: + type: named + name: _update_InvoiceLine_manyMutationResponse + - name: update_Invoice_by_pk + description: "update single row of the table: \"Invoice\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Invoice_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Invoice_set_input + pk_columns: + type: + type: named + name: Invoice_pk_columns_input + result_type: + type: named + name: _update_Invoice_by_pkMutationResponse + - name: update_Invoice_many + description: "update multiples rows of table: \"Invoice\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Invoice_updates + result_type: + type: named + name: _update_Invoice_manyMutationResponse + - name: update_MediaType + description: "update data of the table: \"MediaType\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: MediaType_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: MediaType_bool_exp + result_type: + type: named + name: _update_MediaTypeMutationResponse + - name: update_MediaType_by_pk + description: "update single row of the table: \"MediaType\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: MediaType_set_input + pk_columns: + type: + type: named + name: MediaType_pk_columns_input + result_type: + type: named + name: _update_MediaType_by_pkMutationResponse + - name: update_MediaType_many + description: "update multiples rows of table: \"MediaType\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: MediaType_updates + result_type: + type: named + name: _update_MediaType_manyMutationResponse + - name: update_Playlist + description: "update data of the table: \"Playlist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Playlist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Playlist_bool_exp + result_type: + type: named + name: _update_PlaylistMutationResponse + - name: update_PlaylistTrack + description: "update data of the table: \"PlaylistTrack\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: named + name: _update_PlaylistTrackMutationResponse + - name: update_PlaylistTrack_by_pk + description: "update single row of the table: \"PlaylistTrack\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_set_input + pk_columns: + type: + type: named + name: PlaylistTrack_pk_columns_input + result_type: + type: named + name: _update_PlaylistTrack_by_pkMutationResponse + - name: update_PlaylistTrack_many + description: "update multiples rows of table: \"PlaylistTrack\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: PlaylistTrack_updates + result_type: + type: named + name: _update_PlaylistTrack_manyMutationResponse + - name: update_Playlist_by_pk + description: "update single row of the table: \"Playlist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Playlist_set_input + pk_columns: + type: + type: named + name: Playlist_pk_columns_input + result_type: + type: named + name: _update_Playlist_by_pkMutationResponse + - name: update_Playlist_many + description: "update multiples rows of table: \"Playlist\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Playlist_updates + result_type: + type: named + name: _update_Playlist_manyMutationResponse + - name: update_Track + description: "update data of the table: \"Track\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Track_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Track_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Track_bool_exp + result_type: + type: named + name: _update_TrackMutationResponse + - name: update_Track_by_pk + description: "update single row of the table: \"Track\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Track_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Track_set_input + pk_columns: + type: + type: named + name: Track_pk_columns_input + result_type: + type: named + name: _update_Track_by_pkMutationResponse + - name: update_Track_many + description: "update multiples rows of table: \"Track\"" + arguments: + _headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Track_updates + result_type: + type: named + name: _update_Track_manyMutationResponse diff --git a/crates/ndc-graphql/tests/snapshots/query_builder__config-3 NDC Schema.snap b/crates/ndc-graphql/tests/snapshots/query_builder__config-3 NDC Schema.snap new file mode 100644 index 0000000..92e0316 --- /dev/null +++ b/crates/ndc-graphql/tests/snapshots/query_builder__config-3 NDC Schema.snap @@ -0,0 +1,17890 @@ +--- +source: crates/ndc-graphql/tests/query_builder.rs +expression: schema +--- +scalar_types: + Album_constraint: + representation: + type: enum + one_of: + - PK_Album + aggregate_functions: {} + comparison_operators: {} + Album_select_column: + representation: + type: enum + one_of: + - AlbumId + - ArtistId + - Title + aggregate_functions: {} + comparison_operators: {} + Album_update_column: + representation: + type: enum + one_of: + - ArtistId + - Title + aggregate_functions: {} + comparison_operators: {} + Artist_constraint: + representation: + type: enum + one_of: + - PK_Artist + aggregate_functions: {} + comparison_operators: {} + Artist_select_column: + representation: + type: enum + one_of: + - ArtistId + - Name + aggregate_functions: {} + comparison_operators: {} + Artist_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + Boolean: + aggregate_functions: {} + comparison_operators: {} + Customer_constraint: + representation: + type: enum + one_of: + - PK_Customer + aggregate_functions: {} + comparison_operators: {} + Customer_select_column: + representation: + type: enum + one_of: + - Address + - City + - Company + - Country + - CustomerId + - Email + - Fax + - FirstName + - LastName + - Phone + - PostalCode + - State + - SupportRepId + aggregate_functions: {} + comparison_operators: {} + Customer_update_column: + representation: + type: enum + one_of: + - Address + - City + - Company + - Country + - Email + - Fax + - FirstName + - LastName + - Phone + - PostalCode + - State + - SupportRepId + aggregate_functions: {} + comparison_operators: {} + Employee_constraint: + representation: + type: enum + one_of: + - PK_Employee + aggregate_functions: {} + comparison_operators: {} + Employee_select_column: + representation: + type: enum + one_of: + - Address + - BirthDate + - City + - Country + - Email + - EmployeeId + - Fax + - FirstName + - HireDate + - LastName + - Phone + - PostalCode + - ReportsTo + - State + - Title + aggregate_functions: {} + comparison_operators: {} + Employee_update_column: + representation: + type: enum + one_of: + - Address + - BirthDate + - City + - Country + - Email + - Fax + - FirstName + - HireDate + - LastName + - Phone + - PostalCode + - ReportsTo + - State + - Title + aggregate_functions: {} + comparison_operators: {} + Float: + aggregate_functions: {} + comparison_operators: {} + Genre_constraint: + representation: + type: enum + one_of: + - PK_Genre + aggregate_functions: {} + comparison_operators: {} + Genre_select_column: + representation: + type: enum + one_of: + - GenreId + - Name + aggregate_functions: {} + comparison_operators: {} + Genre_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + Int: + aggregate_functions: {} + comparison_operators: {} + InvoiceLine_constraint: + representation: + type: enum + one_of: + - PK_InvoiceLine + aggregate_functions: {} + comparison_operators: {} + InvoiceLine_select_column: + representation: + type: enum + one_of: + - InvoiceId + - InvoiceLineId + - Quantity + - TrackId + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + InvoiceLine_update_column: + representation: + type: enum + one_of: + - InvoiceId + - Quantity + - TrackId + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + Invoice_constraint: + representation: + type: enum + one_of: + - PK_Invoice + aggregate_functions: {} + comparison_operators: {} + Invoice_select_column: + representation: + type: enum + one_of: + - BillingAddress + - BillingCity + - BillingCountry + - BillingPostalCode + - BillingState + - CustomerId + - InvoiceDate + - InvoiceId + - Total + aggregate_functions: {} + comparison_operators: {} + Invoice_update_column: + representation: + type: enum + one_of: + - BillingAddress + - BillingCity + - BillingCountry + - BillingPostalCode + - BillingState + - CustomerId + - InvoiceDate + - Total + aggregate_functions: {} + comparison_operators: {} + MediaType_constraint: + representation: + type: enum + one_of: + - PK_MediaType + aggregate_functions: {} + comparison_operators: {} + MediaType_select_column: + representation: + type: enum + one_of: + - MediaTypeId + - Name + aggregate_functions: {} + comparison_operators: {} + MediaType_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + PlaylistTrack_constraint: + representation: + type: enum + one_of: + - PK_PlaylistTrack + aggregate_functions: {} + comparison_operators: {} + PlaylistTrack_select_column: + representation: + type: enum + one_of: + - PlaylistId + - TrackId + aggregate_functions: {} + comparison_operators: {} + PlaylistTrack_update_column: + representation: + type: enum + one_of: + - PlaylistId + - TrackId + aggregate_functions: {} + comparison_operators: {} + Playlist_constraint: + representation: + type: enum + one_of: + - PK_Playlist + aggregate_functions: {} + comparison_operators: {} + Playlist_select_column: + representation: + type: enum + one_of: + - Name + - PlaylistId + aggregate_functions: {} + comparison_operators: {} + Playlist_update_column: + representation: + type: enum + one_of: + - Name + aggregate_functions: {} + comparison_operators: {} + String: + aggregate_functions: {} + comparison_operators: {} + Track_constraint: + representation: + type: enum + one_of: + - PK_Track + aggregate_functions: {} + comparison_operators: {} + Track_select_column: + representation: + type: enum + one_of: + - AlbumId + - Bytes + - Composer + - GenreId + - MediaTypeId + - Milliseconds + - Name + - TrackId + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + Track_update_column: + representation: + type: enum + one_of: + - AlbumId + - Bytes + - Composer + - GenreId + - MediaTypeId + - Milliseconds + - Name + - UnitPrice + aggregate_functions: {} + comparison_operators: {} + _HeaderMap: + representation: + type: json + aggregate_functions: {} + comparison_operators: {} + cursor_ordering: + representation: + type: enum + one_of: + - ASC + - DESC + aggregate_functions: {} + comparison_operators: {} + numeric: + aggregate_functions: {} + comparison_operators: {} + order_by: + representation: + type: enum + one_of: + - asc + - asc_nulls_first + - asc_nulls_last + - desc + - desc_nulls_first + - desc_nulls_last + aggregate_functions: {} + comparison_operators: {} + timestamp: + aggregate_functions: {} + comparison_operators: {} +object_types: + Album: + description: "columns and relationships of \"Album\"" + fields: + AlbumId: + type: + type: named + name: Int + Artist: + description: An object relationship + type: + type: named + name: Artist + ArtistId: + type: + type: named + name: Int + Title: + type: + type: named + name: String + Tracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + description: An aggregate relationship + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Album_aggregate: + description: "aggregated selection of \"Album\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Album + Album_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_bool_exp_count + Album_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Album_aggregate_fields: + description: "aggregate fields of \"Album\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Album_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Album_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Album_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Album_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Album_variance_fields + Album_aggregate_order_by: + description: "order by aggregate values of table \"Album\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Album_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Album_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Album_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Album_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Album_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Album_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Album_variance_order_by + Album_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Album\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + Album_avg_fields: + description: aggregate avg on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_avg_order_by: + description: "order by avg() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_bool_exp: + description: "Boolean expression to filter rows from the table \"Album\". All fields are combined with a logical 'AND'." + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Artist: + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Title: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_bool_exp + Album_inc_input: + description: "input type for incrementing numeric columns in table \"Album\"" + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Album_insert_input: + description: "input type for inserting data into table \"Album\"" + fields: + Artist: + type: + type: nullable + underlying_type: + type: named + name: Artist_obj_rel_insert_input + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_arr_rel_insert_input + Album_max_fields: + description: aggregate max on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_max_order_by: + description: "order by max() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_min_fields: + description: aggregate min on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_min_order_by: + description: "order by min() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_mutation_response: + description: "response of any mutation on the table \"Album\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Album + Album_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Album\"" + fields: + data: + type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + Album_on_conflict: + description: "on_conflict condition type for table \"Album\"" + fields: + constraint: + type: + type: named + name: Album_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Album_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Album_order_by: + description: "Ordering options when selecting data from \"Album\"." + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Artist: + type: + type: nullable + underlying_type: + type: named + name: Artist_order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_order_by + Album_pk_columns_input: + description: "primary key columns input for table: Album" + fields: + AlbumId: + type: + type: named + name: Int + Album_set_input: + description: "input type for updating data in table \"Album\"" + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_stddev_fields: + description: aggregate stddev on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_stddev_order_by: + description: "order by stddev() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_stream_cursor_input: + description: "Streaming cursor of the table \"Album\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Album_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Album_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Album_sum_fields: + description: aggregate sum on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Album_sum_order_by: + description: "order by sum() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Album_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Album_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Album_bool_exp + Album_var_pop_fields: + description: aggregate var_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_var_pop_order_by: + description: "order by var_pop() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_var_samp_fields: + description: aggregate var_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_var_samp_order_by: + description: "order by var_samp() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Album_variance_fields: + description: aggregate variance on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Album_variance_order_by: + description: "order by variance() on columns of table \"Album\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Artist: + description: "columns and relationships of \"Artist\"" + fields: + Albums: + description: An array relationship + type: + type: array + element_type: + type: named + name: Album + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Albums_aggregate: + description: An aggregate relationship + type: + type: named + name: Album_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + ArtistId: + type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_aggregate: + description: "aggregated selection of \"Artist\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Artist_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Artist + Artist_aggregate_fields: + description: "aggregate fields of \"Artist\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Artist_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Artist_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Artist_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Artist_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Artist_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Artist_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Artist_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Artist_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Artist_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Artist_variance_fields + Artist_avg_fields: + description: aggregate avg on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_bool_exp: + description: "Boolean expression to filter rows from the table \"Artist\". All fields are combined with a logical 'AND'." + fields: + Albums: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Albums_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_bool_exp + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_bool_exp + Artist_insert_input: + description: "input type for inserting data into table \"Artist\"" + fields: + Albums: + type: + type: nullable + underlying_type: + type: named + name: Album_arr_rel_insert_input + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_max_fields: + description: aggregate max on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_min_fields: + description: aggregate min on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_mutation_response: + description: "response of any mutation on the table \"Artist\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Artist + Artist_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Artist\"" + fields: + data: + type: + type: named + name: Artist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Artist_on_conflict + Artist_on_conflict: + description: "on_conflict condition type for table \"Artist\"" + fields: + constraint: + type: + type: named + name: Artist_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Artist_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Artist_order_by: + description: "Ordering options when selecting data from \"Artist\"." + fields: + Albums_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Album_aggregate_order_by + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + Artist_pk_columns_input: + description: "primary key columns input for table: Artist" + fields: + ArtistId: + type: + type: named + name: Int + Artist_set_input: + description: "input type for updating data in table \"Artist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_stddev_fields: + description: aggregate stddev on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_stream_cursor_input: + description: "Streaming cursor of the table \"Artist\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Artist_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Artist_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Artist_sum_fields: + description: aggregate sum on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Artist_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Artist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Artist_bool_exp + Artist_var_pop_fields: + description: aggregate var_pop on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_var_samp_fields: + description: aggregate var_samp on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Artist_variance_fields: + description: aggregate variance on columns + fields: + ArtistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer: + description: "columns and relationships of \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: named + name: Int + Email: + type: + type: named + name: String + Employee: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Employee + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: named + name: String + Invoices: + description: An array relationship + type: + type: array + element_type: + type: named + name: Invoice + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoices_aggregate: + description: An aggregate relationship + type: + type: named + name: Invoice_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + LastName: + type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_aggregate: + description: "aggregated selection of \"Customer\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Customer + Customer_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_bool_exp_count + Customer_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Customer_aggregate_fields: + description: "aggregate fields of \"Customer\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Customer_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Customer_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Customer_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Customer_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Customer_variance_fields + Customer_aggregate_order_by: + description: "order by aggregate values of table \"Customer\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Customer_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Customer_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Customer_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Customer_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Customer_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Customer_variance_order_by + Customer_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Customer\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + Customer_avg_fields: + description: aggregate avg on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_avg_order_by: + description: "order by avg() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_bool_exp: + description: "Boolean expression to filter rows from the table \"Customer\". All fields are combined with a logical 'AND'." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + City: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Company: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Country: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Email: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Fax: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Invoices: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoices_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_bool_exp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Phone: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + State: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_bool_exp + Customer_inc_input: + description: "input type for incrementing numeric columns in table \"Customer\"" + fields: + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_insert_input: + description: "input type for inserting data into table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_obj_rel_insert_input + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + Invoices: + type: + type: nullable + underlying_type: + type: named + name: Invoice_arr_rel_insert_input + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_max_fields: + description: aggregate max on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_max_order_by: + description: "order by max() on columns of table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Company: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_min_fields: + description: aggregate min on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_min_order_by: + description: "order by min() on columns of table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Company: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_mutation_response: + description: "response of any mutation on the table \"Customer\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Customer + Customer_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Customer\"" + fields: + data: + type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + Customer_on_conflict: + description: "on_conflict condition type for table \"Customer\"" + fields: + constraint: + type: + type: named + name: Customer_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Customer_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customer_order_by: + description: "Ordering options when selecting data from \"Customer\"." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Company: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoices_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_pk_columns_input: + description: "primary key columns input for table: Customer" + fields: + CustomerId: + type: + type: named + name: Int + Customer_set_input: + description: "input type for updating data in table \"Customer\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_stddev_fields: + description: aggregate stddev on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_stddev_order_by: + description: "order by stddev() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_stream_cursor_input: + description: "Streaming cursor of the table \"Customer\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Customer_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Customer_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + City: + type: + type: nullable + underlying_type: + type: named + name: String + Company: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + State: + type: + type: nullable + underlying_type: + type: named + name: String + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_sum_fields: + description: aggregate sum on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Int + Customer_sum_order_by: + description: "order by sum() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Customer_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Customer_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Customer_bool_exp + Customer_var_pop_fields: + description: aggregate var_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_var_pop_order_by: + description: "order by var_pop() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_var_samp_fields: + description: aggregate var_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_var_samp_order_by: + description: "order by var_samp() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer_variance_fields: + description: aggregate variance on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: Float + Customer_variance_order_by: + description: "order by variance() on columns of table \"Customer\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + SupportRepId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee: + description: "columns and relationships of \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Customers: + description: An array relationship + type: + type: array + element_type: + type: named + name: Customer + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customers_aggregate: + description: An aggregate relationship + type: + type: named + name: Customer_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Employee: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Employee + EmployeeId: + type: + type: named + name: Int + Employees: + description: An array relationship + type: + type: array + element_type: + type: named + name: Employee + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employees_aggregate: + description: An aggregate relationship + type: + type: named + name: Employee_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_aggregate: + description: "aggregated selection of \"Employee\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Employee + Employee_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_bool_exp_count + Employee_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Employee_aggregate_fields: + description: "aggregate fields of \"Employee\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Employee_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Employee_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Employee_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Employee_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Employee_variance_fields + Employee_aggregate_order_by: + description: "order by aggregate values of table \"Employee\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Employee_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Employee_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Employee_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Employee_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Employee_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Employee_variance_order_by + Employee_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Employee\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + Employee_avg_fields: + description: aggregate avg on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_avg_order_by: + description: "order by avg() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_bool_exp: + description: "Boolean expression to filter rows from the table \"Employee\". All fields are combined with a logical 'AND'." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp_comparison_exp + City: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Country: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Customers: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customers_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_bool_exp + Email: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Employees: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employees_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_bool_exp + Fax: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp_comparison_exp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Phone: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + State: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Title: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_bool_exp + Employee_inc_input: + description: "input type for incrementing numeric columns in table \"Employee\"" + fields: + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + Employee_insert_input: + description: "input type for inserting data into table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Customers: + type: + type: nullable + underlying_type: + type: named + name: Customer_arr_rel_insert_input + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_obj_rel_insert_input + Employees: + type: + type: nullable + underlying_type: + type: named + name: Employee_arr_rel_insert_input + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_max_fields: + description: aggregate max on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_max_order_by: + description: "order by max() on columns of table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + HireDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_min_fields: + description: aggregate min on columns + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_min_order_by: + description: "order by min() on columns of table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + HireDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_mutation_response: + description: "response of any mutation on the table \"Employee\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Employee + Employee_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Employee\"" + fields: + data: + type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + Employee_on_conflict: + description: "on_conflict condition type for table \"Employee\"" + fields: + constraint: + type: + type: named + name: Employee_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Employee_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employee_order_by: + description: "Ordering options when selecting data from \"Employee\"." + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: order_by + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + City: + type: + type: nullable + underlying_type: + type: named + name: order_by + Country: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customers_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Customer_aggregate_order_by + Email: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee: + type: + type: nullable + underlying_type: + type: named + name: Employee_order_by + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employees_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Employee_aggregate_order_by + Fax: + type: + type: nullable + underlying_type: + type: named + name: order_by + FirstName: + type: + type: nullable + underlying_type: + type: named + name: order_by + HireDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + LastName: + type: + type: nullable + underlying_type: + type: named + name: order_by + Phone: + type: + type: nullable + underlying_type: + type: named + name: order_by + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + State: + type: + type: nullable + underlying_type: + type: named + name: order_by + Title: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_pk_columns_input: + description: "primary key columns input for table: Employee" + fields: + EmployeeId: + type: + type: named + name: Int + Employee_set_input: + description: "input type for updating data in table \"Employee\"" + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_stddev_fields: + description: aggregate stddev on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_stddev_order_by: + description: "order by stddev() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_stream_cursor_input: + description: "Streaming cursor of the table \"Employee\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Employee_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Employee_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + Address: + type: + type: nullable + underlying_type: + type: named + name: String + BirthDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + City: + type: + type: nullable + underlying_type: + type: named + name: String + Country: + type: + type: nullable + underlying_type: + type: named + name: String + Email: + type: + type: nullable + underlying_type: + type: named + name: String + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Fax: + type: + type: nullable + underlying_type: + type: named + name: String + FirstName: + type: + type: nullable + underlying_type: + type: named + name: String + HireDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + LastName: + type: + type: nullable + underlying_type: + type: named + name: String + Phone: + type: + type: nullable + underlying_type: + type: named + name: String + PostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + State: + type: + type: nullable + underlying_type: + type: named + name: String + Title: + type: + type: nullable + underlying_type: + type: named + name: String + Employee_sum_fields: + description: aggregate sum on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Int + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Int + Employee_sum_order_by: + description: "order by sum() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Employee_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Employee_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Employee_bool_exp + Employee_var_pop_fields: + description: aggregate var_pop on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_var_pop_order_by: + description: "order by var_pop() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_var_samp_fields: + description: aggregate var_samp on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_var_samp_order_by: + description: "order by var_samp() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Employee_variance_fields: + description: aggregate variance on columns + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: Float + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: Float + Employee_variance_order_by: + description: "order by variance() on columns of table \"Employee\"" + fields: + EmployeeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + ReportsTo: + type: + type: nullable + underlying_type: + type: named + name: order_by + Genre: + description: "columns and relationships of \"Genre\"" + fields: + GenreId: + type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + description: An aggregate relationship + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Genre_aggregate: + description: "aggregated selection of \"Genre\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Genre_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Genre + Genre_aggregate_fields: + description: "aggregate fields of \"Genre\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Genre_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Genre_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Genre_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Genre_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Genre_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Genre_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Genre_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Genre_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Genre_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Genre_variance_fields + Genre_avg_fields: + description: aggregate avg on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_bool_exp: + description: "Boolean expression to filter rows from the table \"Genre\". All fields are combined with a logical 'AND'." + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_bool_exp + Genre_insert_input: + description: "input type for inserting data into table \"Genre\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_arr_rel_insert_input + Genre_max_fields: + description: aggregate max on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_min_fields: + description: aggregate min on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_mutation_response: + description: "response of any mutation on the table \"Genre\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Genre + Genre_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Genre\"" + fields: + data: + type: + type: named + name: Genre_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Genre_on_conflict + Genre_on_conflict: + description: "on_conflict condition type for table \"Genre\"" + fields: + constraint: + type: + type: named + name: Genre_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Genre_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Genre_order_by: + description: "Ordering options when selecting data from \"Genre\"." + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_order_by + Genre_pk_columns_input: + description: "primary key columns input for table: Genre" + fields: + GenreId: + type: + type: named + name: Int + Genre_set_input: + description: "input type for updating data in table \"Genre\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_stddev_fields: + description: aggregate stddev on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_stream_cursor_input: + description: "Streaming cursor of the table \"Genre\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Genre_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Genre_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Genre_sum_fields: + description: aggregate sum on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + Genre_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Genre_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Genre_bool_exp + Genre_var_pop_fields: + description: aggregate var_pop on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_var_samp_fields: + description: aggregate var_samp on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Genre_variance_fields: + description: aggregate variance on columns + fields: + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + Int_comparison_exp: + description: "Boolean expression to compare columns of type \"Int\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: Int + _gt: + type: + type: nullable + underlying_type: + type: named + name: Int + _gte: + type: + type: nullable + underlying_type: + type: named + name: Int + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Int + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _lt: + type: + type: nullable + underlying_type: + type: named + name: Int + _lte: + type: + type: nullable + underlying_type: + type: named + name: Int + _neq: + type: + type: nullable + underlying_type: + type: named + name: Int + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Int + Invoice: + description: "columns and relationships of \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + Customer: + description: An object relationship + type: + type: named + name: Customer + CustomerId: + type: + type: named + name: Int + InvoiceDate: + type: + type: named + name: timestamp + InvoiceId: + type: + type: named + name: Int + InvoiceLines: + description: An array relationship + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + description: An aggregate relationship + type: + type: named + name: InvoiceLine_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + Total: + type: + type: named + name: numeric + InvoiceLine: + description: "columns and relationships of \"InvoiceLine\"" + fields: + Invoice: + description: An object relationship + type: + type: named + name: Invoice + InvoiceId: + type: + type: named + name: Int + InvoiceLineId: + type: + type: named + name: Int + Quantity: + type: + type: named + name: Int + Track: + description: An object relationship + type: + type: named + name: Track + TrackId: + type: + type: named + name: Int + UnitPrice: + type: + type: named + name: numeric + InvoiceLine_aggregate: + description: "aggregated selection of \"InvoiceLine\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: InvoiceLine + InvoiceLine_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_bool_exp_count + InvoiceLine_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + InvoiceLine_aggregate_fields: + description: "aggregate fields of \"InvoiceLine\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_variance_fields + InvoiceLine_aggregate_order_by: + description: "order by aggregate values of table \"InvoiceLine\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_variance_order_by + InvoiceLine_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"InvoiceLine\"" + fields: + data: + type: + type: array + element_type: + type: named + name: InvoiceLine_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_on_conflict + InvoiceLine_avg_fields: + description: aggregate avg on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_avg_order_by: + description: "order by avg() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_bool_exp: + description: "Boolean expression to filter rows from the table \"InvoiceLine\". All fields are combined with a logical 'AND'." + fields: + Invoice: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_inc_input: + description: "input type for incrementing numeric columns in table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_insert_input: + description: "input type for inserting data into table \"InvoiceLine\"" + fields: + Invoice: + type: + type: nullable + underlying_type: + type: named + name: Invoice_obj_rel_insert_input + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_obj_rel_insert_input + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_max_fields: + description: aggregate max on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_max_order_by: + description: "order by max() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_min_fields: + description: aggregate min on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_min_order_by: + description: "order by min() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_mutation_response: + description: "response of any mutation on the table \"InvoiceLine\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: InvoiceLine + InvoiceLine_on_conflict: + description: "on_conflict condition type for table \"InvoiceLine\"" + fields: + constraint: + type: + type: named + name: InvoiceLine_constraint + update_columns: + type: + type: array + element_type: + type: named + name: InvoiceLine_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_order_by: + description: "Ordering options when selecting data from \"InvoiceLine\"." + fields: + Invoice: + type: + type: nullable + underlying_type: + type: named + name: Invoice_order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_pk_columns_input: + description: "primary key columns input for table: InvoiceLine" + fields: + InvoiceLineId: + type: + type: named + name: Int + InvoiceLine_set_input: + description: "input type for updating data in table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_stddev_fields: + description: aggregate stddev on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_stddev_order_by: + description: "order by stddev() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_stream_cursor_input: + description: "Streaming cursor of the table \"InvoiceLine\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: InvoiceLine_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + InvoiceLine_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_sum_fields: + description: aggregate sum on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Int + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + InvoiceLine_sum_order_by: + description: "order by sum() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_var_pop_fields: + description: aggregate var_pop on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_var_pop_order_by: + description: "order by var_pop() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_var_samp_fields: + description: aggregate var_samp on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_var_samp_order_by: + description: "order by var_samp() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLine_variance_fields: + description: aggregate variance on columns + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: Float + Quantity: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceLine_variance_order_by: + description: "order by variance() on columns of table \"InvoiceLine\"" + fields: + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLineId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Quantity: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_aggregate: + description: "aggregated selection of \"Invoice\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Invoice + Invoice_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Invoice_aggregate_bool_exp_count + Invoice_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Invoice_aggregate_fields: + description: "aggregate fields of \"Invoice\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Invoice_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Invoice_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Invoice_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Invoice_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Invoice_variance_fields + Invoice_aggregate_order_by: + description: "order by aggregate values of table \"Invoice\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Invoice_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Invoice_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Invoice_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Invoice_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Invoice_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Invoice_variance_order_by + Invoice_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Invoice\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + Invoice_avg_fields: + description: aggregate avg on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_avg_order_by: + description: "order by avg() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_bool_exp: + description: "Boolean expression to filter rows from the table \"Invoice\". All fields are combined with a logical 'AND'." + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Customer: + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp_comparison_exp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_bool_exp + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_bool_exp + Invoice_inc_input: + description: "input type for incrementing numeric columns in table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_insert_input: + description: "input type for inserting data into table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + Customer: + type: + type: nullable + underlying_type: + type: named + name: Customer_obj_rel_insert_input + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_arr_rel_insert_input + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_max_fields: + description: aggregate max on columns + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_max_order_by: + description: "order by max() on columns of table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingState: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_min_fields: + description: aggregate min on columns + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_min_order_by: + description: "order by min() on columns of table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingState: + type: + type: nullable + underlying_type: + type: named + name: order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_mutation_response: + description: "response of any mutation on the table \"Invoice\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Invoice + Invoice_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Invoice\"" + fields: + data: + type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + Invoice_on_conflict: + description: "on_conflict condition type for table \"Invoice\"" + fields: + constraint: + type: + type: named + name: Invoice_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Invoice_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoice_order_by: + description: "Ordering options when selecting data from \"Invoice\"." + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: order_by + BillingState: + type: + type: nullable + underlying_type: + type: named + name: order_by + Customer: + type: + type: nullable + underlying_type: + type: named + name: Customer_order_by + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_pk_columns_input: + description: "primary key columns input for table: Invoice" + fields: + InvoiceId: + type: + type: named + name: Int + Invoice_set_input: + description: "input type for updating data in table \"Invoice\"" + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_stddev_fields: + description: aggregate stddev on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_stddev_order_by: + description: "order by stddev() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_stream_cursor_input: + description: "Streaming cursor of the table \"Invoice\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Invoice_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Invoice_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + BillingAddress: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCity: + type: + type: nullable + underlying_type: + type: named + name: String + BillingCountry: + type: + type: nullable + underlying_type: + type: named + name: String + BillingPostalCode: + type: + type: nullable + underlying_type: + type: named + name: String + BillingState: + type: + type: nullable + underlying_type: + type: named + name: String + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceDate: + type: + type: nullable + underlying_type: + type: named + name: timestamp + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_sum_fields: + description: aggregate sum on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Int + Total: + type: + type: nullable + underlying_type: + type: named + name: numeric + Invoice_sum_order_by: + description: "order by sum() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Invoice_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Invoice_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Invoice_bool_exp + Invoice_var_pop_fields: + description: aggregate var_pop on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_var_pop_order_by: + description: "order by var_pop() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_var_samp_fields: + description: aggregate var_samp on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_var_samp_order_by: + description: "order by var_samp() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + Invoice_variance_fields: + description: aggregate variance on columns + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: Float + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: Float + Total: + type: + type: nullable + underlying_type: + type: named + name: Float + Invoice_variance_order_by: + description: "order by variance() on columns of table \"Invoice\"" + fields: + CustomerId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Total: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaType: + description: "columns and relationships of \"MediaType\"" + fields: + MediaTypeId: + type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + description: An aggregate relationship + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + MediaType_aggregate: + description: "aggregated selection of \"MediaType\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: MediaType_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: MediaType + MediaType_aggregate_fields: + description: "aggregate fields of \"MediaType\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: MediaType_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: MediaType_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: MediaType_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: MediaType_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: MediaType_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: MediaType_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: MediaType_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: MediaType_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: MediaType_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: MediaType_variance_fields + MediaType_avg_fields: + description: aggregate avg on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_bool_exp: + description: "Boolean expression to filter rows from the table \"MediaType\". All fields are combined with a logical 'AND'." + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_bool_exp + MediaType_insert_input: + description: "input type for inserting data into table \"MediaType\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Tracks: + type: + type: nullable + underlying_type: + type: named + name: Track_arr_rel_insert_input + MediaType_max_fields: + description: aggregate max on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_min_fields: + description: aggregate min on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_mutation_response: + description: "response of any mutation on the table \"MediaType\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: MediaType + MediaType_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"MediaType\"" + fields: + data: + type: + type: named + name: MediaType_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: MediaType_on_conflict + MediaType_on_conflict: + description: "on_conflict condition type for table \"MediaType\"" + fields: + constraint: + type: + type: named + name: MediaType_constraint + update_columns: + type: + type: array + element_type: + type: named + name: MediaType_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaType_order_by: + description: "Ordering options when selecting data from \"MediaType\"." + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + Tracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_order_by + MediaType_pk_columns_input: + description: "primary key columns input for table: MediaType" + fields: + MediaTypeId: + type: + type: named + name: Int + MediaType_set_input: + description: "input type for updating data in table \"MediaType\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_stddev_fields: + description: aggregate stddev on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_stream_cursor_input: + description: "Streaming cursor of the table \"MediaType\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: MediaType_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + MediaType_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + MediaType_sum_fields: + description: aggregate sum on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaType_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: MediaType_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: MediaType_bool_exp + MediaType_var_pop_fields: + description: aggregate var_pop on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_var_samp_fields: + description: aggregate var_samp on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaType_variance_fields: + description: aggregate variance on columns + fields: + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist: + description: "columns and relationships of \"Playlist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: named + name: Int + PlaylistTracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + description: An aggregate relationship + type: + type: named + name: PlaylistTrack_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack: + description: "columns and relationships of \"PlaylistTrack\"" + fields: + Playlist: + description: An object relationship + type: + type: named + name: Playlist + PlaylistId: + type: + type: named + name: Int + Track: + description: An object relationship + type: + type: named + name: Track + TrackId: + type: + type: named + name: Int + PlaylistTrack_aggregate: + description: "aggregated selection of \"PlaylistTrack\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: PlaylistTrack + PlaylistTrack_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_bool_exp_count + PlaylistTrack_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + PlaylistTrack_aggregate_fields: + description: "aggregate fields of \"PlaylistTrack\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_variance_fields + PlaylistTrack_aggregate_order_by: + description: "order by aggregate values of table \"PlaylistTrack\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_variance_order_by + PlaylistTrack_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"PlaylistTrack\"" + fields: + data: + type: + type: array + element_type: + type: named + name: PlaylistTrack_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_on_conflict + PlaylistTrack_avg_fields: + description: aggregate avg on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_avg_order_by: + description: "order by avg() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_bool_exp: + description: "Boolean expression to filter rows from the table \"PlaylistTrack\". All fields are combined with a logical 'AND'." + fields: + Playlist: + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_inc_input: + description: "input type for incrementing numeric columns in table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_insert_input: + description: "input type for inserting data into table \"PlaylistTrack\"" + fields: + Playlist: + type: + type: nullable + underlying_type: + type: named + name: Playlist_obj_rel_insert_input + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_obj_rel_insert_input + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_max_fields: + description: aggregate max on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_max_order_by: + description: "order by max() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_min_fields: + description: aggregate min on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_min_order_by: + description: "order by min() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_mutation_response: + description: "response of any mutation on the table \"PlaylistTrack\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: PlaylistTrack + PlaylistTrack_on_conflict: + description: "on_conflict condition type for table \"PlaylistTrack\"" + fields: + constraint: + type: + type: named + name: PlaylistTrack_constraint + update_columns: + type: + type: array + element_type: + type: named + name: PlaylistTrack_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_order_by: + description: "Ordering options when selecting data from \"PlaylistTrack\"." + fields: + Playlist: + type: + type: nullable + underlying_type: + type: named + name: Playlist_order_by + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track: + type: + type: nullable + underlying_type: + type: named + name: Track_order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_pk_columns_input: + description: "primary key columns input for table: PlaylistTrack" + fields: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + PlaylistTrack_set_input: + description: "input type for updating data in table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_stddev_fields: + description: aggregate stddev on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_stddev_order_by: + description: "order by stddev() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_stream_cursor_input: + description: "Streaming cursor of the table \"PlaylistTrack\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: PlaylistTrack_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + PlaylistTrack_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_sum_fields: + description: aggregate sum on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + PlaylistTrack_sum_order_by: + description: "order by sum() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_var_pop_fields: + description: aggregate var_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_var_pop_order_by: + description: "order by var_pop() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_var_samp_fields: + description: aggregate var_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_var_samp_order_by: + description: "order by var_samp() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTrack_variance_fields: + description: aggregate variance on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + PlaylistTrack_variance_order_by: + description: "order by variance() on columns of table \"PlaylistTrack\"" + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Playlist_aggregate: + description: "aggregated selection of \"Playlist\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Playlist_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Playlist + Playlist_aggregate_fields: + description: "aggregate fields of \"Playlist\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Playlist_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Playlist_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Playlist_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Playlist_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Playlist_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Playlist_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Playlist_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Playlist_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Playlist_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Playlist_variance_fields + Playlist_avg_fields: + description: aggregate avg on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_bool_exp: + description: "Boolean expression to filter rows from the table \"Playlist\". All fields are combined with a logical 'AND'." + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_bool_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_bool_exp + Playlist_insert_input: + description: "input type for inserting data into table \"Playlist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_arr_rel_insert_input + Playlist_max_fields: + description: aggregate max on columns + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_min_fields: + description: aggregate min on columns + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_mutation_response: + description: "response of any mutation on the table \"Playlist\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Playlist + Playlist_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Playlist\"" + fields: + data: + type: + type: named + name: Playlist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Playlist_on_conflict + Playlist_on_conflict: + description: "on_conflict condition type for table \"Playlist\"" + fields: + constraint: + type: + type: named + name: Playlist_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Playlist_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + Playlist_order_by: + description: "Ordering options when selecting data from \"Playlist\"." + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_order_by + Playlist_pk_columns_input: + description: "primary key columns input for table: Playlist" + fields: + PlaylistId: + type: + type: named + name: Int + Playlist_set_input: + description: "input type for updating data in table \"Playlist\"" + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + Playlist_stddev_fields: + description: aggregate stddev on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_stream_cursor_input: + description: "Streaming cursor of the table \"Playlist\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Playlist_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Playlist_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_sum_fields: + description: aggregate sum on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Int + Playlist_updates: + fields: + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Playlist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Playlist_bool_exp + Playlist_var_pop_fields: + description: aggregate var_pop on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_var_samp_fields: + description: aggregate var_samp on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + Playlist_variance_fields: + description: aggregate variance on columns + fields: + PlaylistId: + type: + type: nullable + underlying_type: + type: named + name: Float + String_comparison_exp: + description: "Boolean expression to compare columns of type \"String\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: String + _gt: + type: + type: nullable + underlying_type: + type: named + name: String + _gte: + type: + type: nullable + underlying_type: + type: named + name: String + _ilike: + description: does the column match the given case-insensitive pattern + type: + type: nullable + underlying_type: + type: named + name: String + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: String + _iregex: + description: "does the column match the given POSIX regular expression, case insensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _like: + description: does the column match the given pattern + type: + type: nullable + underlying_type: + type: named + name: String + _lt: + type: + type: nullable + underlying_type: + type: named + name: String + _lte: + type: + type: nullable + underlying_type: + type: named + name: String + _neq: + type: + type: nullable + underlying_type: + type: named + name: String + _nilike: + description: does the column NOT match the given case-insensitive pattern + type: + type: nullable + underlying_type: + type: named + name: String + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: String + _niregex: + description: "does the column NOT match the given POSIX regular expression, case insensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _nlike: + description: does the column NOT match the given pattern + type: + type: nullable + underlying_type: + type: named + name: String + _nregex: + description: "does the column NOT match the given POSIX regular expression, case sensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _nsimilar: + description: does the column NOT match the given SQL regular expression + type: + type: nullable + underlying_type: + type: named + name: String + _regex: + description: "does the column match the given POSIX regular expression, case sensitive" + type: + type: nullable + underlying_type: + type: named + name: String + _similar: + description: does the column match the given SQL regular expression + type: + type: nullable + underlying_type: + type: named + name: String + Track: + description: "columns and relationships of \"Track\"" + fields: + Album: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Album + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + Genre: + description: An object relationship + type: + type: nullable + underlying_type: + type: named + name: Genre + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLines: + description: An array relationship + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + description: An aggregate relationship + type: + type: named + name: InvoiceLine_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + MediaType: + description: An object relationship + type: + type: named + name: MediaType + MediaTypeId: + type: + type: named + name: Int + Milliseconds: + type: + type: named + name: Int + Name: + type: + type: named + name: String + PlaylistTracks: + description: An array relationship + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + description: An aggregate relationship + type: + type: named + name: PlaylistTrack_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + TrackId: + type: + type: named + name: Int + UnitPrice: + type: + type: named + name: numeric + Track_aggregate: + description: "aggregated selection of \"Track\"" + fields: + aggregate: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_fields + nodes: + type: + type: array + element_type: + type: named + name: Track + Track_aggregate_bool_exp: + fields: + count: + type: + type: nullable + underlying_type: + type: named + name: Track_aggregate_bool_exp_count + Track_aggregate_bool_exp_count: + fields: + arguments: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + filter: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + predicate: + type: + type: named + name: Int_comparison_exp + Track_aggregate_fields: + description: "aggregate fields of \"Track\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Track_avg_fields + count: + type: + type: named + name: Int + arguments: + columns: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + distinct: + type: + type: nullable + underlying_type: + type: named + name: Boolean + max: + type: + type: nullable + underlying_type: + type: named + name: Track_max_fields + min: + type: + type: nullable + underlying_type: + type: named + name: Track_min_fields + stddev: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_fields + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_pop_fields + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_samp_fields + sum: + type: + type: nullable + underlying_type: + type: named + name: Track_sum_fields + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_var_pop_fields + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_var_samp_fields + variance: + type: + type: nullable + underlying_type: + type: named + name: Track_variance_fields + Track_aggregate_order_by: + description: "order by aggregate values of table \"Track\"" + fields: + avg: + type: + type: nullable + underlying_type: + type: named + name: Track_avg_order_by + count: + type: + type: nullable + underlying_type: + type: named + name: order_by + max: + type: + type: nullable + underlying_type: + type: named + name: Track_max_order_by + min: + type: + type: nullable + underlying_type: + type: named + name: Track_min_order_by + stddev: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_order_by + stddev_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_pop_order_by + stddev_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_stddev_samp_order_by + sum: + type: + type: nullable + underlying_type: + type: named + name: Track_sum_order_by + var_pop: + type: + type: nullable + underlying_type: + type: named + name: Track_var_pop_order_by + var_samp: + type: + type: nullable + underlying_type: + type: named + name: Track_var_samp_order_by + variance: + type: + type: nullable + underlying_type: + type: named + name: Track_variance_order_by + Track_arr_rel_insert_input: + description: "input type for inserting array relation for remote table \"Track\"" + fields: + data: + type: + type: array + element_type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + Track_avg_fields: + description: aggregate avg on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_avg_order_by: + description: "order by avg() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_bool_exp: + description: "Boolean expression to filter rows from the table \"Track\". All fields are combined with a logical 'AND'." + fields: + Album: + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Composer: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + Genre: + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_bool_exp + MediaType: + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + Name: + type: + type: nullable + underlying_type: + type: named + name: String_comparison_exp + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_bool_exp + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int_comparison_exp + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric_comparison_exp + _and: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_bool_exp + _not: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + _or: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_bool_exp + Track_inc_input: + description: "input type for incrementing numeric columns in table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_insert_input: + description: "input type for inserting data into table \"Track\"" + fields: + Album: + type: + type: nullable + underlying_type: + type: named + name: Album_obj_rel_insert_input + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + Genre: + type: + type: nullable + underlying_type: + type: named + name: Genre_obj_rel_insert_input + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + InvoiceLines: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_arr_rel_insert_input + MediaType: + type: + type: nullable + underlying_type: + type: named + name: MediaType_obj_rel_insert_input + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + PlaylistTracks: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_arr_rel_insert_input + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_max_fields: + description: aggregate max on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_max_order_by: + description: "order by max() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + Composer: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_min_fields: + description: aggregate min on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_min_order_by: + description: "order by min() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + Composer: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_mutation_response: + description: "response of any mutation on the table \"Track\"" + fields: + affected_rows: + description: number of rows affected by the mutation + type: + type: named + name: Int + returning: + description: data from the rows affected by the mutation + type: + type: array + element_type: + type: named + name: Track + Track_obj_rel_insert_input: + description: "input type for inserting object relation for remote table \"Track\"" + fields: + data: + type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + Track_on_conflict: + description: "on_conflict condition type for table \"Track\"" + fields: + constraint: + type: + type: named + name: Track_constraint + update_columns: + type: + type: array + element_type: + type: named + name: Track_update_column + where: + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Track_order_by: + description: "Ordering options when selecting data from \"Track\"." + fields: + Album: + type: + type: nullable + underlying_type: + type: named + name: Album_order_by + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + Composer: + type: + type: nullable + underlying_type: + type: named + name: order_by + Genre: + type: + type: nullable + underlying_type: + type: named + name: Genre_order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + InvoiceLines_aggregate: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_aggregate_order_by + MediaType: + type: + type: nullable + underlying_type: + type: named + name: MediaType_order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + Name: + type: + type: nullable + underlying_type: + type: named + name: order_by + PlaylistTracks_aggregate: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_aggregate_order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_pk_columns_input: + description: "primary key columns input for table: Track" + fields: + TrackId: + type: + type: named + name: Int + Track_set_input: + description: "input type for updating data in table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_stddev_fields: + description: aggregate stddev on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_stddev_order_by: + description: "order by stddev() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_stddev_pop_fields: + description: aggregate stddev_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_stddev_pop_order_by: + description: "order by stddev_pop() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_stddev_samp_fields: + description: aggregate stddev_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_stddev_samp_order_by: + description: "order by stddev_samp() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_stream_cursor_input: + description: "Streaming cursor of the table \"Track\"" + fields: + initial_value: + description: Stream column input with initial value + type: + type: named + name: Track_stream_cursor_value_input + ordering: + description: cursor ordering + type: + type: nullable + underlying_type: + type: named + name: cursor_ordering + Track_stream_cursor_value_input: + description: Initial value of the column from where the streaming should start + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + Composer: + type: + type: nullable + underlying_type: + type: named + name: String + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + Name: + type: + type: nullable + underlying_type: + type: named + name: String + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_sum_fields: + description: aggregate sum on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Int + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Int + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Int + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Int + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Int + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Int + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: numeric + Track_sum_order_by: + description: "order by sum() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_updates: + fields: + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Track_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Track_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Track_bool_exp + Track_var_pop_fields: + description: aggregate var_pop on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_var_pop_order_by: + description: "order by var_pop() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_var_samp_fields: + description: aggregate var_samp on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_var_samp_order_by: + description: "order by var_samp() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + Track_variance_fields: + description: aggregate variance on columns + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: Float + Bytes: + type: + type: nullable + underlying_type: + type: named + name: Float + GenreId: + type: + type: nullable + underlying_type: + type: named + name: Float + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: Float + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: Float + TrackId: + type: + type: nullable + underlying_type: + type: named + name: Float + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: Float + Track_variance_order_by: + description: "order by variance() on columns of table \"Track\"" + fields: + AlbumId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Bytes: + type: + type: nullable + underlying_type: + type: named + name: order_by + GenreId: + type: + type: nullable + underlying_type: + type: named + name: order_by + MediaTypeId: + type: + type: nullable + underlying_type: + type: named + name: order_by + Milliseconds: + type: + type: nullable + underlying_type: + type: named + name: order_by + TrackId: + type: + type: nullable + underlying_type: + type: named + name: order_by + UnitPrice: + type: + type: nullable + underlying_type: + type: named + name: order_by + _AlbumQueryResponse: + description: Response type for function Album + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Album + _Album_aggregateQueryResponse: + description: Response type for function Album_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Album_aggregate + _Album_by_pkQueryResponse: + description: Response type for function Album_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album + _ArtistQueryResponse: + description: Response type for function Artist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Artist + _Artist_aggregateQueryResponse: + description: Response type for function Artist_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Artist_aggregate + _Artist_by_pkQueryResponse: + description: Response type for function Artist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist + _CustomerQueryResponse: + description: Response type for function Customer + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Customer + _Customer_aggregateQueryResponse: + description: Response type for function Customer_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Customer_aggregate + _Customer_by_pkQueryResponse: + description: Response type for function Customer_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer + _EmployeeQueryResponse: + description: Response type for function Employee + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Employee + _Employee_aggregateQueryResponse: + description: Response type for function Employee_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Employee_aggregate + _Employee_by_pkQueryResponse: + description: Response type for function Employee_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee + _GenreQueryResponse: + description: Response type for function Genre + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Genre + _Genre_aggregateQueryResponse: + description: Response type for function Genre_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Genre_aggregate + _Genre_by_pkQueryResponse: + description: Response type for function Genre_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre + _InvoiceLineQueryResponse: + description: Response type for function InvoiceLine + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: InvoiceLine + _InvoiceLine_aggregateQueryResponse: + description: Response type for function InvoiceLine_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: InvoiceLine_aggregate + _InvoiceLine_by_pkQueryResponse: + description: Response type for function InvoiceLine_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + _InvoiceQueryResponse: + description: Response type for function Invoice + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Invoice + _Invoice_aggregateQueryResponse: + description: Response type for function Invoice_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Invoice_aggregate + _Invoice_by_pkQueryResponse: + description: Response type for function Invoice_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice + _MediaTypeQueryResponse: + description: Response type for function MediaType + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: MediaType + _MediaType_aggregateQueryResponse: + description: Response type for function MediaType_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: MediaType_aggregate + _MediaType_by_pkQueryResponse: + description: Response type for function MediaType_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType + _PlaylistQueryResponse: + description: Response type for function Playlist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Playlist + _PlaylistTrackQueryResponse: + description: Response type for function PlaylistTrack + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: PlaylistTrack + _PlaylistTrack_aggregateQueryResponse: + description: Response type for function PlaylistTrack_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: PlaylistTrack_aggregate + _PlaylistTrack_by_pkQueryResponse: + description: Response type for function PlaylistTrack_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + _Playlist_aggregateQueryResponse: + description: Response type for function Playlist_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Playlist_aggregate + _Playlist_by_pkQueryResponse: + description: Response type for function Playlist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist + _TrackQueryResponse: + description: Response type for function Track + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: array + element_type: + type: named + name: Track + _Track_aggregateQueryResponse: + description: Response type for function Track_aggregate + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: named + name: Track_aggregate + _Track_by_pkQueryResponse: + description: Response type for function Track_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track + _delete_AlbumMutationResponse: + description: Response type for procedure delete_Album + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + _delete_Album_by_pkMutationResponse: + description: Response type for procedure delete_Album_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album + _delete_ArtistMutationResponse: + description: Response type for procedure delete_Artist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + _delete_Artist_by_pkMutationResponse: + description: Response type for procedure delete_Artist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist + _delete_CustomerMutationResponse: + description: Response type for procedure delete_Customer + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + _delete_Customer_by_pkMutationResponse: + description: Response type for procedure delete_Customer_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer + _delete_EmployeeMutationResponse: + description: Response type for procedure delete_Employee + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + _delete_Employee_by_pkMutationResponse: + description: Response type for procedure delete_Employee_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee + _delete_GenreMutationResponse: + description: Response type for procedure delete_Genre + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + _delete_Genre_by_pkMutationResponse: + description: Response type for procedure delete_Genre_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre + _delete_InvoiceLineMutationResponse: + description: Response type for procedure delete_InvoiceLine + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + _delete_InvoiceLine_by_pkMutationResponse: + description: Response type for procedure delete_InvoiceLine_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + _delete_InvoiceMutationResponse: + description: Response type for procedure delete_Invoice + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + _delete_Invoice_by_pkMutationResponse: + description: Response type for procedure delete_Invoice_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice + _delete_MediaTypeMutationResponse: + description: Response type for procedure delete_MediaType + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + _delete_MediaType_by_pkMutationResponse: + description: Response type for procedure delete_MediaType_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType + _delete_PlaylistMutationResponse: + description: Response type for procedure delete_Playlist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + _delete_PlaylistTrackMutationResponse: + description: Response type for procedure delete_PlaylistTrack + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + _delete_PlaylistTrack_by_pkMutationResponse: + description: Response type for procedure delete_PlaylistTrack_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + _delete_Playlist_by_pkMutationResponse: + description: Response type for procedure delete_Playlist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist + _delete_TrackMutationResponse: + description: Response type for procedure delete_Track + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + _delete_Track_by_pkMutationResponse: + description: Response type for procedure delete_Track_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track + _insert_AlbumMutationResponse: + description: Response type for procedure insert_Album + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + _insert_Album_oneMutationResponse: + description: Response type for procedure insert_Album_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album + _insert_ArtistMutationResponse: + description: Response type for procedure insert_Artist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + _insert_Artist_oneMutationResponse: + description: Response type for procedure insert_Artist_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist + _insert_CustomerMutationResponse: + description: Response type for procedure insert_Customer + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + _insert_Customer_oneMutationResponse: + description: Response type for procedure insert_Customer_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer + _insert_EmployeeMutationResponse: + description: Response type for procedure insert_Employee + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + _insert_Employee_oneMutationResponse: + description: Response type for procedure insert_Employee_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee + _insert_GenreMutationResponse: + description: Response type for procedure insert_Genre + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + _insert_Genre_oneMutationResponse: + description: Response type for procedure insert_Genre_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre + _insert_InvoiceLineMutationResponse: + description: Response type for procedure insert_InvoiceLine + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + _insert_InvoiceLine_oneMutationResponse: + description: Response type for procedure insert_InvoiceLine_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + _insert_InvoiceMutationResponse: + description: Response type for procedure insert_Invoice + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + _insert_Invoice_oneMutationResponse: + description: Response type for procedure insert_Invoice_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice + _insert_MediaTypeMutationResponse: + description: Response type for procedure insert_MediaType + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + _insert_MediaType_oneMutationResponse: + description: Response type for procedure insert_MediaType_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType + _insert_PlaylistMutationResponse: + description: Response type for procedure insert_Playlist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + _insert_PlaylistTrackMutationResponse: + description: Response type for procedure insert_PlaylistTrack + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + _insert_PlaylistTrack_oneMutationResponse: + description: Response type for procedure insert_PlaylistTrack_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + _insert_Playlist_oneMutationResponse: + description: Response type for procedure insert_Playlist_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist + _insert_TrackMutationResponse: + description: Response type for procedure insert_Track + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + _insert_Track_oneMutationResponse: + description: Response type for procedure insert_Track_one + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track + _update_AlbumMutationResponse: + description: Response type for procedure update_Album + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + _update_Album_by_pkMutationResponse: + description: Response type for procedure update_Album_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Album + _update_Album_manyMutationResponse: + description: Response type for procedure update_Album_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Album_mutation_response + _update_ArtistMutationResponse: + description: Response type for procedure update_Artist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + _update_Artist_by_pkMutationResponse: + description: Response type for procedure update_Artist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Artist + _update_Artist_manyMutationResponse: + description: Response type for procedure update_Artist_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Artist_mutation_response + _update_CustomerMutationResponse: + description: Response type for procedure update_Customer + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + _update_Customer_by_pkMutationResponse: + description: Response type for procedure update_Customer_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Customer + _update_Customer_manyMutationResponse: + description: Response type for procedure update_Customer_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Customer_mutation_response + _update_EmployeeMutationResponse: + description: Response type for procedure update_Employee + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + _update_Employee_by_pkMutationResponse: + description: Response type for procedure update_Employee_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Employee + _update_Employee_manyMutationResponse: + description: Response type for procedure update_Employee_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Employee_mutation_response + _update_GenreMutationResponse: + description: Response type for procedure update_Genre + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + _update_Genre_by_pkMutationResponse: + description: Response type for procedure update_Genre_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Genre + _update_Genre_manyMutationResponse: + description: Response type for procedure update_Genre_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Genre_mutation_response + _update_InvoiceLineMutationResponse: + description: Response type for procedure update_InvoiceLine + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + _update_InvoiceLine_by_pkMutationResponse: + description: Response type for procedure update_InvoiceLine_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + _update_InvoiceLine_manyMutationResponse: + description: Response type for procedure update_InvoiceLine_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_mutation_response + _update_InvoiceMutationResponse: + description: Response type for procedure update_Invoice + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + _update_Invoice_by_pkMutationResponse: + description: Response type for procedure update_Invoice_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Invoice + _update_Invoice_manyMutationResponse: + description: Response type for procedure update_Invoice_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Invoice_mutation_response + _update_MediaTypeMutationResponse: + description: Response type for procedure update_MediaType + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + _update_MediaType_by_pkMutationResponse: + description: Response type for procedure update_MediaType_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: MediaType + _update_MediaType_manyMutationResponse: + description: Response type for procedure update_MediaType_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: MediaType_mutation_response + _update_PlaylistMutationResponse: + description: Response type for procedure update_Playlist + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + _update_PlaylistTrackMutationResponse: + description: Response type for procedure update_PlaylistTrack + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + _update_PlaylistTrack_by_pkMutationResponse: + description: Response type for procedure update_PlaylistTrack_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + _update_PlaylistTrack_manyMutationResponse: + description: Response type for procedure update_PlaylistTrack_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_mutation_response + _update_Playlist_by_pkMutationResponse: + description: Response type for procedure update_Playlist_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Playlist + _update_Playlist_manyMutationResponse: + description: Response type for procedure update_Playlist_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Playlist_mutation_response + _update_TrackMutationResponse: + description: Response type for procedure update_Track + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + _update_Track_by_pkMutationResponse: + description: Response type for procedure update_Track_by_pk + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: named + name: Track + _update_Track_manyMutationResponse: + description: Response type for procedure update_Track_many + fields: + headers: + type: + type: named + name: _HeaderMap + response: + type: + type: nullable + underlying_type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Track_mutation_response + numeric_comparison_exp: + description: "Boolean expression to compare columns of type \"numeric\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: numeric + _gt: + type: + type: nullable + underlying_type: + type: named + name: numeric + _gte: + type: + type: nullable + underlying_type: + type: named + name: numeric + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: numeric + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _lt: + type: + type: nullable + underlying_type: + type: named + name: numeric + _lte: + type: + type: nullable + underlying_type: + type: named + name: numeric + _neq: + type: + type: nullable + underlying_type: + type: named + name: numeric + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: numeric + subscription_root: + fields: + Album: + description: "fetch data from the table: \"Album\"" + type: + type: array + element_type: + type: named + name: Album + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Album_aggregate: + description: "fetch aggregated fields from the table: \"Album\"" + type: + type: named + name: Album_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Album_by_pk: + description: "fetch data from the table: \"Album\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Album + arguments: + AlbumId: + type: + type: named + name: Int + Album_stream: + description: "fetch data from the table in a streaming manner: \"Album\"" + type: + type: array + element_type: + type: named + name: Album + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Album_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + Artist: + description: "fetch data from the table: \"Artist\"" + type: + type: array + element_type: + type: named + name: Artist + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Artist_aggregate: + description: "fetch aggregated fields from the table: \"Artist\"" + type: + type: named + name: Artist_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Artist_by_pk: + description: "fetch data from the table: \"Artist\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Artist + arguments: + ArtistId: + type: + type: named + name: Int + Artist_stream: + description: "fetch data from the table in a streaming manner: \"Artist\"" + type: + type: array + element_type: + type: named + name: Artist + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Artist_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + Customer: + description: "fetch data from the table: \"Customer\"" + type: + type: array + element_type: + type: named + name: Customer + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customer_aggregate: + description: "fetch aggregated fields from the table: \"Customer\"" + type: + type: named + name: Customer_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Customer_by_pk: + description: "fetch data from the table: \"Customer\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Customer + arguments: + CustomerId: + type: + type: named + name: Int + Customer_stream: + description: "fetch data from the table in a streaming manner: \"Customer\"" + type: + type: array + element_type: + type: named + name: Customer + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Customer_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + Employee: + description: "fetch data from the table: \"Employee\"" + type: + type: array + element_type: + type: named + name: Employee + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employee_aggregate: + description: "fetch aggregated fields from the table: \"Employee\"" + type: + type: named + name: Employee_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Employee_by_pk: + description: "fetch data from the table: \"Employee\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Employee + arguments: + EmployeeId: + type: + type: named + name: Int + Employee_stream: + description: "fetch data from the table in a streaming manner: \"Employee\"" + type: + type: array + element_type: + type: named + name: Employee + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Employee_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + Genre: + description: "fetch data from the table: \"Genre\"" + type: + type: array + element_type: + type: named + name: Genre + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Genre_aggregate: + description: "fetch aggregated fields from the table: \"Genre\"" + type: + type: named + name: Genre_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Genre_by_pk: + description: "fetch data from the table: \"Genre\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Genre + arguments: + GenreId: + type: + type: named + name: Int + Genre_stream: + description: "fetch data from the table in a streaming manner: \"Genre\"" + type: + type: array + element_type: + type: named + name: Genre + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Genre_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + Invoice: + description: "fetch data from the table: \"Invoice\"" + type: + type: array + element_type: + type: named + name: Invoice + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + InvoiceLine: + description: "fetch data from the table: \"InvoiceLine\"" + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_aggregate: + description: "fetch aggregated fields from the table: \"InvoiceLine\"" + type: + type: named + name: InvoiceLine_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + InvoiceLine_by_pk: + description: "fetch data from the table: \"InvoiceLine\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine + arguments: + InvoiceLineId: + type: + type: named + name: Int + InvoiceLine_stream: + description: "fetch data from the table in a streaming manner: \"InvoiceLine\"" + type: + type: array + element_type: + type: named + name: InvoiceLine + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + Invoice_aggregate: + description: "fetch aggregated fields from the table: \"Invoice\"" + type: + type: named + name: Invoice_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + Invoice_by_pk: + description: "fetch data from the table: \"Invoice\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Invoice + arguments: + InvoiceId: + type: + type: named + name: Int + Invoice_stream: + description: "fetch data from the table in a streaming manner: \"Invoice\"" + type: + type: array + element_type: + type: named + name: Invoice + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Invoice_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + MediaType: + description: "fetch data from the table: \"MediaType\"" + type: + type: array + element_type: + type: named + name: MediaType + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaType_aggregate: + description: "fetch aggregated fields from the table: \"MediaType\"" + type: + type: named + name: MediaType_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + MediaType_by_pk: + description: "fetch data from the table: \"MediaType\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: MediaType + arguments: + MediaTypeId: + type: + type: named + name: Int + MediaType_stream: + description: "fetch data from the table in a streaming manner: \"MediaType\"" + type: + type: array + element_type: + type: named + name: MediaType + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: MediaType_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + Playlist: + description: "fetch data from the table: \"Playlist\"" + type: + type: array + element_type: + type: named + name: Playlist + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + PlaylistTrack: + description: "fetch data from the table: \"PlaylistTrack\"" + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_aggregate: + description: "fetch aggregated fields from the table: \"PlaylistTrack\"" + type: + type: named + name: PlaylistTrack_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + PlaylistTrack_by_pk: + description: "fetch data from the table: \"PlaylistTrack\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack + arguments: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + PlaylistTrack_stream: + description: "fetch data from the table in a streaming manner: \"PlaylistTrack\"" + type: + type: array + element_type: + type: named + name: PlaylistTrack + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + Playlist_aggregate: + description: "fetch aggregated fields from the table: \"Playlist\"" + type: + type: named + name: Playlist_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + Playlist_by_pk: + description: "fetch data from the table: \"Playlist\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Playlist + arguments: + PlaylistId: + type: + type: named + name: Int + Playlist_stream: + description: "fetch data from the table in a streaming manner: \"Playlist\"" + type: + type: array + element_type: + type: named + name: Playlist + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Playlist_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + Track: + description: "fetch data from the table: \"Track\"" + type: + type: array + element_type: + type: named + name: Track + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Track_aggregate: + description: "fetch aggregated fields from the table: \"Track\"" + type: + type: named + name: Track_aggregate + arguments: + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + Track_by_pk: + description: "fetch data from the table: \"Track\" using primary key columns" + type: + type: nullable + underlying_type: + type: named + name: Track + arguments: + TrackId: + type: + type: named + name: Int + Track_stream: + description: "fetch data from the table in a streaming manner: \"Track\"" + type: + type: array + element_type: + type: named + name: Track + arguments: + batch_size: + description: maximum number of rows returned in a single batch + type: + type: named + name: Int + cursor: + description: cursor to stream the results returned by the query + type: + type: array + element_type: + type: nullable + underlying_type: + type: named + name: Track_stream_cursor_input + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + timestamp_comparison_exp: + description: "Boolean expression to compare columns of type \"timestamp\". All fields are combined with logical 'AND'." + fields: + _eq: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _gt: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _gte: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _in: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: timestamp + _is_null: + type: + type: nullable + underlying_type: + type: named + name: Boolean + _lt: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _lte: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _neq: + type: + type: nullable + underlying_type: + type: named + name: timestamp + _nin: + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: timestamp +collections: [] +functions: + - name: Album + description: "fetch data from the table: \"Album\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + result_type: + type: named + name: _AlbumQueryResponse + - name: Album_aggregate + description: "fetch aggregated fields from the table: \"Album\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Album_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Album_bool_exp + result_type: + type: named + name: _Album_aggregateQueryResponse + - name: Album_by_pk + description: "fetch data from the table: \"Album\" using primary key columns" + arguments: + AlbumId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Album_by_pkQueryResponse + - name: Artist + description: "fetch data from the table: \"Artist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + result_type: + type: named + name: _ArtistQueryResponse + - name: Artist_aggregate + description: "fetch aggregated fields from the table: \"Artist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Artist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Artist_bool_exp + result_type: + type: named + name: _Artist_aggregateQueryResponse + - name: Artist_by_pk + description: "fetch data from the table: \"Artist\" using primary key columns" + arguments: + ArtistId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Artist_by_pkQueryResponse + - name: Customer + description: "fetch data from the table: \"Customer\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + result_type: + type: named + name: _CustomerQueryResponse + - name: Customer_aggregate + description: "fetch aggregated fields from the table: \"Customer\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Customer_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Customer_bool_exp + result_type: + type: named + name: _Customer_aggregateQueryResponse + - name: Customer_by_pk + description: "fetch data from the table: \"Customer\" using primary key columns" + arguments: + CustomerId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Customer_by_pkQueryResponse + - name: Employee + description: "fetch data from the table: \"Employee\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + result_type: + type: named + name: _EmployeeQueryResponse + - name: Employee_aggregate + description: "fetch aggregated fields from the table: \"Employee\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Employee_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Employee_bool_exp + result_type: + type: named + name: _Employee_aggregateQueryResponse + - name: Employee_by_pk + description: "fetch data from the table: \"Employee\" using primary key columns" + arguments: + EmployeeId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Employee_by_pkQueryResponse + - name: Genre + description: "fetch data from the table: \"Genre\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + result_type: + type: named + name: _GenreQueryResponse + - name: Genre_aggregate + description: "fetch aggregated fields from the table: \"Genre\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Genre_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Genre_bool_exp + result_type: + type: named + name: _Genre_aggregateQueryResponse + - name: Genre_by_pk + description: "fetch data from the table: \"Genre\" using primary key columns" + arguments: + GenreId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Genre_by_pkQueryResponse + - name: Invoice + description: "fetch data from the table: \"Invoice\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + result_type: + type: named + name: _InvoiceQueryResponse + - name: InvoiceLine + description: "fetch data from the table: \"InvoiceLine\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: named + name: _InvoiceLineQueryResponse + - name: InvoiceLine_aggregate + description: "fetch aggregated fields from the table: \"InvoiceLine\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: InvoiceLine_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: named + name: _InvoiceLine_aggregateQueryResponse + - name: InvoiceLine_by_pk + description: "fetch data from the table: \"InvoiceLine\" using primary key columns" + arguments: + InvoiceLineId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _InvoiceLine_by_pkQueryResponse + - name: Invoice_aggregate + description: "fetch aggregated fields from the table: \"Invoice\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Invoice_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Invoice_bool_exp + result_type: + type: named + name: _Invoice_aggregateQueryResponse + - name: Invoice_by_pk + description: "fetch data from the table: \"Invoice\" using primary key columns" + arguments: + InvoiceId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Invoice_by_pkQueryResponse + - name: MediaType + description: "fetch data from the table: \"MediaType\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + result_type: + type: named + name: _MediaTypeQueryResponse + - name: MediaType_aggregate + description: "fetch aggregated fields from the table: \"MediaType\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: MediaType_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: MediaType_bool_exp + result_type: + type: named + name: _MediaType_aggregateQueryResponse + - name: MediaType_by_pk + description: "fetch data from the table: \"MediaType\" using primary key columns" + arguments: + MediaTypeId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _MediaType_by_pkQueryResponse + - name: Playlist + description: "fetch data from the table: \"Playlist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + result_type: + type: named + name: _PlaylistQueryResponse + - name: PlaylistTrack + description: "fetch data from the table: \"PlaylistTrack\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: named + name: _PlaylistTrackQueryResponse + - name: PlaylistTrack_aggregate + description: "fetch aggregated fields from the table: \"PlaylistTrack\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: PlaylistTrack_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: named + name: _PlaylistTrack_aggregateQueryResponse + - name: PlaylistTrack_by_pk + description: "fetch data from the table: \"PlaylistTrack\" using primary key columns" + arguments: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _PlaylistTrack_by_pkQueryResponse + - name: Playlist_aggregate + description: "fetch aggregated fields from the table: \"Playlist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Playlist_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Playlist_bool_exp + result_type: + type: named + name: _Playlist_aggregateQueryResponse + - name: Playlist_by_pk + description: "fetch data from the table: \"Playlist\" using primary key columns" + arguments: + PlaylistId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Playlist_by_pkQueryResponse + - name: Track + description: "fetch data from the table: \"Track\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + result_type: + type: named + name: _TrackQueryResponse + - name: Track_aggregate + description: "fetch aggregated fields from the table: \"Track\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + distinct_on: + description: distinct select on columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_select_column + limit: + description: limit the number of rows returned + type: + type: nullable + underlying_type: + type: named + name: Int + offset: + description: skip the first n rows. Use only with order_by + type: + type: nullable + underlying_type: + type: named + name: Int + order_by: + description: sort the rows by one or more columns + type: + type: nullable + underlying_type: + type: array + element_type: + type: named + name: Track_order_by + where: + description: filter the rows returned + type: + type: nullable + underlying_type: + type: named + name: Track_bool_exp + result_type: + type: named + name: _Track_aggregateQueryResponse + - name: Track_by_pk + description: "fetch data from the table: \"Track\" using primary key columns" + arguments: + TrackId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _Track_by_pkQueryResponse +procedures: + - name: delete_Album + description: "delete data from the table: \"Album\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Album_bool_exp + result_type: + type: named + name: _delete_AlbumMutationResponse + - name: delete_Album_by_pk + description: "delete single row from the table: \"Album\"" + arguments: + AlbumId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Album_by_pkMutationResponse + - name: delete_Artist + description: "delete data from the table: \"Artist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Artist_bool_exp + result_type: + type: named + name: _delete_ArtistMutationResponse + - name: delete_Artist_by_pk + description: "delete single row from the table: \"Artist\"" + arguments: + ArtistId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Artist_by_pkMutationResponse + - name: delete_Customer + description: "delete data from the table: \"Customer\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Customer_bool_exp + result_type: + type: named + name: _delete_CustomerMutationResponse + - name: delete_Customer_by_pk + description: "delete single row from the table: \"Customer\"" + arguments: + CustomerId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Customer_by_pkMutationResponse + - name: delete_Employee + description: "delete data from the table: \"Employee\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Employee_bool_exp + result_type: + type: named + name: _delete_EmployeeMutationResponse + - name: delete_Employee_by_pk + description: "delete single row from the table: \"Employee\"" + arguments: + EmployeeId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Employee_by_pkMutationResponse + - name: delete_Genre + description: "delete data from the table: \"Genre\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Genre_bool_exp + result_type: + type: named + name: _delete_GenreMutationResponse + - name: delete_Genre_by_pk + description: "delete single row from the table: \"Genre\"" + arguments: + GenreId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Genre_by_pkMutationResponse + - name: delete_Invoice + description: "delete data from the table: \"Invoice\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Invoice_bool_exp + result_type: + type: named + name: _delete_InvoiceMutationResponse + - name: delete_InvoiceLine + description: "delete data from the table: \"InvoiceLine\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: named + name: _delete_InvoiceLineMutationResponse + - name: delete_InvoiceLine_by_pk + description: "delete single row from the table: \"InvoiceLine\"" + arguments: + InvoiceLineId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_InvoiceLine_by_pkMutationResponse + - name: delete_Invoice_by_pk + description: "delete single row from the table: \"Invoice\"" + arguments: + InvoiceId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Invoice_by_pkMutationResponse + - name: delete_MediaType + description: "delete data from the table: \"MediaType\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: MediaType_bool_exp + result_type: + type: named + name: _delete_MediaTypeMutationResponse + - name: delete_MediaType_by_pk + description: "delete single row from the table: \"MediaType\"" + arguments: + MediaTypeId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_MediaType_by_pkMutationResponse + - name: delete_Playlist + description: "delete data from the table: \"Playlist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Playlist_bool_exp + result_type: + type: named + name: _delete_PlaylistMutationResponse + - name: delete_PlaylistTrack + description: "delete data from the table: \"PlaylistTrack\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: named + name: _delete_PlaylistTrackMutationResponse + - name: delete_PlaylistTrack_by_pk + description: "delete single row from the table: \"PlaylistTrack\"" + arguments: + PlaylistId: + type: + type: named + name: Int + TrackId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_PlaylistTrack_by_pkMutationResponse + - name: delete_Playlist_by_pk + description: "delete single row from the table: \"Playlist\"" + arguments: + PlaylistId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Playlist_by_pkMutationResponse + - name: delete_Track + description: "delete data from the table: \"Track\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + where: + description: filter the rows which have to be deleted + type: + type: named + name: Track_bool_exp + result_type: + type: named + name: _delete_TrackMutationResponse + - name: delete_Track_by_pk + description: "delete single row from the table: \"Track\"" + arguments: + TrackId: + type: + type: named + name: Int + _forwarded_headers: + type: + type: named + name: _HeaderMap + result_type: + type: named + name: _delete_Track_by_pkMutationResponse + - name: insert_Album + description: "insert data into the table: \"Album\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + result_type: + type: named + name: _insert_AlbumMutationResponse + - name: insert_Album_one + description: "insert a single row into the table: \"Album\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Album_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Album_on_conflict + result_type: + type: named + name: _insert_Album_oneMutationResponse + - name: insert_Artist + description: "insert data into the table: \"Artist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Artist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Artist_on_conflict + result_type: + type: named + name: _insert_ArtistMutationResponse + - name: insert_Artist_one + description: "insert a single row into the table: \"Artist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Artist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Artist_on_conflict + result_type: + type: named + name: _insert_Artist_oneMutationResponse + - name: insert_Customer + description: "insert data into the table: \"Customer\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + result_type: + type: named + name: _insert_CustomerMutationResponse + - name: insert_Customer_one + description: "insert a single row into the table: \"Customer\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Customer_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Customer_on_conflict + result_type: + type: named + name: _insert_Customer_oneMutationResponse + - name: insert_Employee + description: "insert data into the table: \"Employee\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + result_type: + type: named + name: _insert_EmployeeMutationResponse + - name: insert_Employee_one + description: "insert a single row into the table: \"Employee\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Employee_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Employee_on_conflict + result_type: + type: named + name: _insert_Employee_oneMutationResponse + - name: insert_Genre + description: "insert data into the table: \"Genre\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Genre_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Genre_on_conflict + result_type: + type: named + name: _insert_GenreMutationResponse + - name: insert_Genre_one + description: "insert a single row into the table: \"Genre\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Genre_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Genre_on_conflict + result_type: + type: named + name: _insert_Genre_oneMutationResponse + - name: insert_Invoice + description: "insert data into the table: \"Invoice\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + result_type: + type: named + name: _insert_InvoiceMutationResponse + - name: insert_InvoiceLine + description: "insert data into the table: \"InvoiceLine\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: InvoiceLine_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_on_conflict + result_type: + type: named + name: _insert_InvoiceLineMutationResponse + - name: insert_InvoiceLine_one + description: "insert a single row into the table: \"InvoiceLine\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: InvoiceLine_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_on_conflict + result_type: + type: named + name: _insert_InvoiceLine_oneMutationResponse + - name: insert_Invoice_one + description: "insert a single row into the table: \"Invoice\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Invoice_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Invoice_on_conflict + result_type: + type: named + name: _insert_Invoice_oneMutationResponse + - name: insert_MediaType + description: "insert data into the table: \"MediaType\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: MediaType_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: MediaType_on_conflict + result_type: + type: named + name: _insert_MediaTypeMutationResponse + - name: insert_MediaType_one + description: "insert a single row into the table: \"MediaType\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: MediaType_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: MediaType_on_conflict + result_type: + type: named + name: _insert_MediaType_oneMutationResponse + - name: insert_Playlist + description: "insert data into the table: \"Playlist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Playlist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Playlist_on_conflict + result_type: + type: named + name: _insert_PlaylistMutationResponse + - name: insert_PlaylistTrack + description: "insert data into the table: \"PlaylistTrack\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: PlaylistTrack_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_on_conflict + result_type: + type: named + name: _insert_PlaylistTrackMutationResponse + - name: insert_PlaylistTrack_one + description: "insert a single row into the table: \"PlaylistTrack\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: PlaylistTrack_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_on_conflict + result_type: + type: named + name: _insert_PlaylistTrack_oneMutationResponse + - name: insert_Playlist_one + description: "insert a single row into the table: \"Playlist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Playlist_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Playlist_on_conflict + result_type: + type: named + name: _insert_Playlist_oneMutationResponse + - name: insert_Track + description: "insert data into the table: \"Track\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + objects: + description: the rows to be inserted + type: + type: array + element_type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + result_type: + type: named + name: _insert_TrackMutationResponse + - name: insert_Track_one + description: "insert a single row into the table: \"Track\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + object: + description: the row to be inserted + type: + type: named + name: Track_insert_input + on_conflict: + description: upsert condition + type: + type: nullable + underlying_type: + type: named + name: Track_on_conflict + result_type: + type: named + name: _insert_Track_oneMutationResponse + - name: update_Album + description: "update data of the table: \"Album\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Album_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Album_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Album_bool_exp + result_type: + type: named + name: _update_AlbumMutationResponse + - name: update_Album_by_pk + description: "update single row of the table: \"Album\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Album_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Album_set_input + pk_columns: + type: + type: named + name: Album_pk_columns_input + result_type: + type: named + name: _update_Album_by_pkMutationResponse + - name: update_Album_many + description: "update multiples rows of table: \"Album\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Album_updates + result_type: + type: named + name: _update_Album_manyMutationResponse + - name: update_Artist + description: "update data of the table: \"Artist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Artist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Artist_bool_exp + result_type: + type: named + name: _update_ArtistMutationResponse + - name: update_Artist_by_pk + description: "update single row of the table: \"Artist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Artist_set_input + pk_columns: + type: + type: named + name: Artist_pk_columns_input + result_type: + type: named + name: _update_Artist_by_pkMutationResponse + - name: update_Artist_many + description: "update multiples rows of table: \"Artist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Artist_updates + result_type: + type: named + name: _update_Artist_manyMutationResponse + - name: update_Customer + description: "update data of the table: \"Customer\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Customer_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Customer_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Customer_bool_exp + result_type: + type: named + name: _update_CustomerMutationResponse + - name: update_Customer_by_pk + description: "update single row of the table: \"Customer\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Customer_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Customer_set_input + pk_columns: + type: + type: named + name: Customer_pk_columns_input + result_type: + type: named + name: _update_Customer_by_pkMutationResponse + - name: update_Customer_many + description: "update multiples rows of table: \"Customer\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Customer_updates + result_type: + type: named + name: _update_Customer_manyMutationResponse + - name: update_Employee + description: "update data of the table: \"Employee\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Employee_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Employee_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Employee_bool_exp + result_type: + type: named + name: _update_EmployeeMutationResponse + - name: update_Employee_by_pk + description: "update single row of the table: \"Employee\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Employee_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Employee_set_input + pk_columns: + type: + type: named + name: Employee_pk_columns_input + result_type: + type: named + name: _update_Employee_by_pkMutationResponse + - name: update_Employee_many + description: "update multiples rows of table: \"Employee\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Employee_updates + result_type: + type: named + name: _update_Employee_manyMutationResponse + - name: update_Genre + description: "update data of the table: \"Genre\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Genre_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Genre_bool_exp + result_type: + type: named + name: _update_GenreMutationResponse + - name: update_Genre_by_pk + description: "update single row of the table: \"Genre\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Genre_set_input + pk_columns: + type: + type: named + name: Genre_pk_columns_input + result_type: + type: named + name: _update_Genre_by_pkMutationResponse + - name: update_Genre_many + description: "update multiples rows of table: \"Genre\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Genre_updates + result_type: + type: named + name: _update_Genre_manyMutationResponse + - name: update_Invoice + description: "update data of the table: \"Invoice\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Invoice_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Invoice_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Invoice_bool_exp + result_type: + type: named + name: _update_InvoiceMutationResponse + - name: update_InvoiceLine + description: "update data of the table: \"InvoiceLine\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: InvoiceLine_bool_exp + result_type: + type: named + name: _update_InvoiceLineMutationResponse + - name: update_InvoiceLine_by_pk + description: "update single row of the table: \"InvoiceLine\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: InvoiceLine_set_input + pk_columns: + type: + type: named + name: InvoiceLine_pk_columns_input + result_type: + type: named + name: _update_InvoiceLine_by_pkMutationResponse + - name: update_InvoiceLine_many + description: "update multiples rows of table: \"InvoiceLine\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: InvoiceLine_updates + result_type: + type: named + name: _update_InvoiceLine_manyMutationResponse + - name: update_Invoice_by_pk + description: "update single row of the table: \"Invoice\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Invoice_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Invoice_set_input + pk_columns: + type: + type: named + name: Invoice_pk_columns_input + result_type: + type: named + name: _update_Invoice_by_pkMutationResponse + - name: update_Invoice_many + description: "update multiples rows of table: \"Invoice\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Invoice_updates + result_type: + type: named + name: _update_Invoice_manyMutationResponse + - name: update_MediaType + description: "update data of the table: \"MediaType\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: MediaType_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: MediaType_bool_exp + result_type: + type: named + name: _update_MediaTypeMutationResponse + - name: update_MediaType_by_pk + description: "update single row of the table: \"MediaType\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: MediaType_set_input + pk_columns: + type: + type: named + name: MediaType_pk_columns_input + result_type: + type: named + name: _update_MediaType_by_pkMutationResponse + - name: update_MediaType_many + description: "update multiples rows of table: \"MediaType\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: MediaType_updates + result_type: + type: named + name: _update_MediaType_manyMutationResponse + - name: update_Playlist + description: "update data of the table: \"Playlist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Playlist_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Playlist_bool_exp + result_type: + type: named + name: _update_PlaylistMutationResponse + - name: update_PlaylistTrack + description: "update data of the table: \"PlaylistTrack\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: PlaylistTrack_bool_exp + result_type: + type: named + name: _update_PlaylistTrackMutationResponse + - name: update_PlaylistTrack_by_pk + description: "update single row of the table: \"PlaylistTrack\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: PlaylistTrack_set_input + pk_columns: + type: + type: named + name: PlaylistTrack_pk_columns_input + result_type: + type: named + name: _update_PlaylistTrack_by_pkMutationResponse + - name: update_PlaylistTrack_many + description: "update multiples rows of table: \"PlaylistTrack\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: PlaylistTrack_updates + result_type: + type: named + name: _update_PlaylistTrack_manyMutationResponse + - name: update_Playlist_by_pk + description: "update single row of the table: \"Playlist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Playlist_set_input + pk_columns: + type: + type: named + name: Playlist_pk_columns_input + result_type: + type: named + name: _update_Playlist_by_pkMutationResponse + - name: update_Playlist_many + description: "update multiples rows of table: \"Playlist\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Playlist_updates + result_type: + type: named + name: _update_Playlist_manyMutationResponse + - name: update_Track + description: "update data of the table: \"Track\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Track_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Track_set_input + where: + description: filter the rows which have to be updated + type: + type: named + name: Track_bool_exp + result_type: + type: named + name: _update_TrackMutationResponse + - name: update_Track_by_pk + description: "update single row of the table: \"Track\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + _inc: + description: increments the numeric columns with given value of the filtered values + type: + type: nullable + underlying_type: + type: named + name: Track_inc_input + _set: + description: sets the columns of the filtered rows to the given values + type: + type: nullable + underlying_type: + type: named + name: Track_set_input + pk_columns: + type: + type: named + name: Track_pk_columns_input + result_type: + type: named + name: _update_Track_by_pkMutationResponse + - name: update_Track_many + description: "update multiples rows of table: \"Track\"" + arguments: + _forwarded_headers: + type: + type: named + name: _HeaderMap + updates: + description: "updates to execute, in order" + type: + type: array + element_type: + type: named + name: Track_updates + result_type: + type: named + name: _update_Track_manyMutationResponse From 169f0c2a6784911a12957ae1ed3d40bab44e06d2 Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 14:28:57 -0400 Subject: [PATCH 07/11] add introspection tests --- crates/ndc-graphql-cli/src/lib.rs | 1 + crates/ndc-graphql-cli/src/main.rs | 15 +- .../ndc-graphql-cli/tests/introspection.json | 34791 ++++++++++++++++ crates/ndc-graphql-cli/tests/introspection.rs | 21 + ...n__generate_schema_from_introspection.snap | 3754 ++ 5 files changed, 38573 insertions(+), 9 deletions(-) create mode 100644 crates/ndc-graphql-cli/src/lib.rs create mode 100644 crates/ndc-graphql-cli/tests/introspection.json create mode 100644 crates/ndc-graphql-cli/tests/introspection.rs create mode 100644 crates/ndc-graphql-cli/tests/snapshots/introspection__generate_schema_from_introspection.snap diff --git a/crates/ndc-graphql-cli/src/lib.rs b/crates/ndc-graphql-cli/src/lib.rs new file mode 100644 index 0000000..50b9335 --- /dev/null +++ b/crates/ndc-graphql-cli/src/lib.rs @@ -0,0 +1 @@ +pub mod graphql; diff --git a/crates/ndc-graphql-cli/src/main.rs b/crates/ndc-graphql-cli/src/main.rs index 32bae16..0d5105a 100644 --- a/crates/ndc-graphql-cli/src/main.rs +++ b/crates/ndc-graphql-cli/src/main.rs @@ -1,9 +1,3 @@ -use std::{ - env, - error::Error, - path::{Path, PathBuf}, -}; - use clap::{Parser, Subcommand, ValueEnum}; use common::{ config::ConnectionConfig, @@ -14,11 +8,15 @@ use common::{ }; use graphql::{execute_graphql_introspection, schema_from_introspection}; use graphql_parser::schema; +use ndc_graphql_cli::graphql; use schemars::schema_for; +use std::{ + env, + error::Error, + path::{Path, PathBuf}, +}; use tokio::fs; -mod graphql; - #[derive(Parser)] struct CliArgs { /// The PAT token which can be used to make authenticated calls to Hasura Cloud @@ -219,7 +217,6 @@ async fn update_config( let response = execute_graphql_introspection(&connection).await?; - // todo: handle graphql errors! if let Some(errors) = response.errors { return Err(format!("Introspection error: {}", serde_json::to_string(&errors)?).into()); } diff --git a/crates/ndc-graphql-cli/tests/introspection.json b/crates/ndc-graphql-cli/tests/introspection.json new file mode 100644 index 0000000..ca00b31 --- /dev/null +++ b/crates/ndc-graphql-cli/tests/introspection.json @@ -0,0 +1,34791 @@ +{ + "data": { + "__schema": { + "queryType": { + "kind": "OBJECT", + "name": "query_root", + "ofType": null + }, + "mutationType": { + "kind": "OBJECT", + "name": "mutation_root", + "ofType": null + }, + "subscriptionType": { + "kind": "OBJECT", + "name": "subscription_root", + "ofType": null + }, + "types": [ + { + "kind": "OBJECT", + "name": "Album", + "description": "columns and relationships of \"Album\"", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Artist", + "description": "An object relationship", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Tracks", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Tracks_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_aggregate", + "description": "aggregated selection of \"Album\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_aggregate_bool_exp", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "count", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_aggregate_bool_exp_count", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_aggregate_bool_exp_count", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "arguments", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "filter", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "predicate", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_aggregate_fields", + "description": "aggregate fields of \"Album\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_aggregate_order_by", + "description": "order by aggregate values of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "avg", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_avg_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "count", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "max", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_max_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "min", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_min_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_stddev_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_stddev_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_stddev_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "sum", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_sum_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_var_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_var_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "variance", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_variance_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_arr_rel_insert_input", + "description": "input type for inserting array relation for remote table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_avg_order_by", + "description": "order by avg() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "description": "Boolean expression to filter rows from the table \"Album\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Artist", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Album_constraint", + "description": "unique or primary key constraints on table \"Album\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_Album", + "description": "unique or primary key constraint on columns \"AlbumId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_inc_input", + "description": "input type for incrementing numeric columns in table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_insert_input", + "description": "input type for inserting data into table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "Artist", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_max_order_by", + "description": "order by max() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_min_order_by", + "description": "order by min() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_mutation_response", + "description": "response of any mutation on the table \"Album\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_obj_rel_insert_input", + "description": "input type for inserting object relation for remote table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_on_conflict", + "description": "on_conflict condition type for table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_order_by", + "description": "Ordering options when selecting data from \"Album\".", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Artist", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_pk_columns_input", + "description": "primary key columns input for table: Album", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Album_select_column", + "description": "select columns of table \"Album\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "AlbumId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_set_input", + "description": "input type for updating data in table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_stddev_order_by", + "description": "order by stddev() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_stddev_pop_order_by", + "description": "order by stddev_pop() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_stddev_samp_order_by", + "description": "order by stddev_samp() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_stream_cursor_input", + "description": "Streaming cursor of the table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_sum_order_by", + "description": "order by sum() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Album_update_column", + "description": "update columns of table \"Album\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "ArtistId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_var_pop_order_by", + "description": "order by var_pop() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_var_samp_order_by", + "description": "order by var_samp() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Album_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Album_variance_order_by", + "description": "order by variance() on columns of table \"Album\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist", + "description": "columns and relationships of \"Artist\"", + "fields": [ + { + "name": "Albums", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Albums_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_aggregate", + "description": "aggregated selection of \"Artist\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_aggregate_fields", + "description": "aggregate fields of \"Artist\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Artist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Artist_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "description": "Boolean expression to filter rows from the table \"Artist\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "Albums", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Albums_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Artist_constraint", + "description": "unique or primary key constraints on table \"Artist\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_Artist", + "description": "unique or primary key constraint on columns \"ArtistId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_insert_input", + "description": "input type for inserting data into table \"Artist\"", + "fields": null, + "inputFields": [ + { + "name": "Albums", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_mutation_response", + "description": "response of any mutation on the table \"Artist\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_obj_rel_insert_input", + "description": "input type for inserting object relation for remote table \"Artist\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_on_conflict", + "description": "on_conflict condition type for table \"Artist\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Artist_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Artist_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_order_by", + "description": "Ordering options when selecting data from \"Artist\".", + "fields": null, + "inputFields": [ + { + "name": "Albums_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_pk_columns_input", + "description": "primary key columns input for table: Artist", + "fields": null, + "inputFields": [ + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Artist_select_column", + "description": "select columns of table \"Artist\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "ArtistId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_set_input", + "description": "input type for updating data in table \"Artist\"", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_stream_cursor_input", + "description": "Streaming cursor of the table \"Artist\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Artist_update_column", + "description": "update columns of table \"Artist\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Artist_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Artist_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "ArtistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "Boolean", + "description": null, + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer", + "description": "columns and relationships of \"Customer\"", + "fields": [ + { + "name": "Address", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Company", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employee", + "description": "An object relationship", + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Invoices", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Invoices_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_aggregate", + "description": "aggregated selection of \"Customer\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_aggregate_bool_exp", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "count", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_aggregate_bool_exp_count", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_aggregate_bool_exp_count", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "arguments", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "filter", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "predicate", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_aggregate_fields", + "description": "aggregate fields of \"Customer\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Customer_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_aggregate_order_by", + "description": "order by aggregate values of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "avg", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_avg_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "count", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "max", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_max_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "min", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_min_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_stddev_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_stddev_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_stddev_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "sum", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_sum_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_var_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_var_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "variance", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_variance_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_arr_rel_insert_input", + "description": "input type for inserting array relation for remote table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_avg_order_by", + "description": "order by avg() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "description": "Boolean expression to filter rows from the table \"Customer\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Company", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employee", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Invoices", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Invoices_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Customer_constraint", + "description": "unique or primary key constraints on table \"Customer\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_Customer", + "description": "unique or primary key constraint on columns \"CustomerId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_inc_input", + "description": "input type for incrementing numeric columns in table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_insert_input", + "description": "input type for inserting data into table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Company", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employee", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Invoices", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "Address", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Company", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_max_order_by", + "description": "order by max() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Company", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "Address", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Company", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_min_order_by", + "description": "order by min() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Company", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_mutation_response", + "description": "response of any mutation on the table \"Customer\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_obj_rel_insert_input", + "description": "input type for inserting object relation for remote table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_on_conflict", + "description": "on_conflict condition type for table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_order_by", + "description": "Ordering options when selecting data from \"Customer\".", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Company", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employee", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Invoices_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_pk_columns_input", + "description": "primary key columns input for table: Customer", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Customer_select_column", + "description": "select columns of table \"Customer\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Address", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Company", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CustomerId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_set_input", + "description": "input type for updating data in table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Company", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_stddev_order_by", + "description": "order by stddev() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_stddev_pop_order_by", + "description": "order by stddev_pop() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_stddev_samp_order_by", + "description": "order by stddev_samp() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_stream_cursor_input", + "description": "Streaming cursor of the table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Company", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_sum_order_by", + "description": "order by sum() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Customer_update_column", + "description": "update columns of table \"Customer\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Address", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Company", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_var_pop_order_by", + "description": "order by var_pop() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_var_samp_order_by", + "description": "order by var_samp() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Customer_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SupportRepId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Customer_variance_order_by", + "description": "order by variance() on columns of table \"Customer\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "SupportRepId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee", + "description": "columns and relationships of \"Employee\"", + "fields": [ + { + "name": "Address", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BirthDate", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customers", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customers_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employee", + "description": "An object relationship", + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employees", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employees_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "HireDate", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_aggregate", + "description": "aggregated selection of \"Employee\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_aggregate_bool_exp", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "count", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_aggregate_bool_exp_count", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_aggregate_bool_exp_count", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "arguments", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "filter", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "predicate", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_aggregate_fields", + "description": "aggregate fields of \"Employee\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Employee_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_aggregate_order_by", + "description": "order by aggregate values of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "avg", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_avg_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "count", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "max", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_max_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "min", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_min_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_stddev_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_stddev_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_stddev_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "sum", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_sum_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_var_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_var_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "variance", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_variance_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_arr_rel_insert_input", + "description": "input type for inserting array relation for remote table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_avg_order_by", + "description": "order by avg() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "description": "Boolean expression to filter rows from the table \"Employee\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BirthDate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "timestamp_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Customers", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Customers_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employee", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employees", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employees_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "HireDate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "timestamp_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Employee_constraint", + "description": "unique or primary key constraints on table \"Employee\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_Employee", + "description": "unique or primary key constraint on columns \"EmployeeId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_inc_input", + "description": "input type for incrementing numeric columns in table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_insert_input", + "description": "input type for inserting data into table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BirthDate", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Customers", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employee", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employees", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "HireDate", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "Address", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BirthDate", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "HireDate", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_max_order_by", + "description": "order by max() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BirthDate", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "HireDate", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "Address", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BirthDate", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "HireDate", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_min_order_by", + "description": "order by min() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BirthDate", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "HireDate", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_mutation_response", + "description": "response of any mutation on the table \"Employee\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_obj_rel_insert_input", + "description": "input type for inserting object relation for remote table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_on_conflict", + "description": "on_conflict condition type for table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_order_by", + "description": "Ordering options when selecting data from \"Employee\".", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BirthDate", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Customers_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employee", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Employees_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "HireDate", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_pk_columns_input", + "description": "primary key columns input for table: Employee", + "fields": null, + "inputFields": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Employee_select_column", + "description": "select columns of table \"Employee\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Address", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BirthDate", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "EmployeeId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "HireDate", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_set_input", + "description": "input type for updating data in table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BirthDate", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "HireDate", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_stddev_order_by", + "description": "order by stddev() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_stddev_pop_order_by", + "description": "order by stddev_pop() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_stddev_samp_order_by", + "description": "order by stddev_samp() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_stream_cursor_input", + "description": "Streaming cursor of the table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "Address", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BirthDate", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "City", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Country", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Email", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Fax", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "FirstName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "HireDate", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "LastName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Phone", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PostalCode", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "State", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Title", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_sum_order_by", + "description": "order by sum() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Employee_update_column", + "description": "update columns of table \"Employee\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Address", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BirthDate", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "City", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Country", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Email", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Fax", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FirstName", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "HireDate", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LastName", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Phone", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PostalCode", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "State", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Title", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_var_pop_order_by", + "description": "order by var_pop() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_var_samp_order_by", + "description": "order by var_samp() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Employee_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "EmployeeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ReportsTo", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Employee_variance_order_by", + "description": "order by variance() on columns of table \"Employee\"", + "fields": null, + "inputFields": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "ReportsTo", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "Float", + "description": null, + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre", + "description": "columns and relationships of \"Genre\"", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Tracks", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Tracks_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_aggregate", + "description": "aggregated selection of \"Genre\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_aggregate_fields", + "description": "aggregate fields of \"Genre\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Genre_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "description": "Boolean expression to filter rows from the table \"Genre\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "GenreId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Genre_constraint", + "description": "unique or primary key constraints on table \"Genre\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_Genre", + "description": "unique or primary key constraint on columns \"GenreId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_insert_input", + "description": "input type for inserting data into table \"Genre\"", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_mutation_response", + "description": "response of any mutation on the table \"Genre\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_obj_rel_insert_input", + "description": "input type for inserting object relation for remote table \"Genre\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_on_conflict", + "description": "on_conflict condition type for table \"Genre\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Genre_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Genre_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_order_by", + "description": "Ordering options when selecting data from \"Genre\".", + "fields": null, + "inputFields": [ + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_pk_columns_input", + "description": "primary key columns input for table: Genre", + "fields": null, + "inputFields": [ + { + "name": "GenreId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Genre_select_column", + "description": "select columns of table \"Genre\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "GenreId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_set_input", + "description": "input type for updating data in table \"Genre\"", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_stream_cursor_input", + "description": "Streaming cursor of the table \"Genre\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "GenreId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Genre_update_column", + "description": "update columns of table \"Genre\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Genre_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Genre_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "Int", + "description": null, + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "description": "Boolean expression to compare columns of type \"Int\". All fields are combined with logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "_eq", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_gt", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_gte", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_in", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_is_null", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_lt", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_lte", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_neq", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_nin", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice", + "description": "columns and relationships of \"Invoice\"", + "fields": [ + { + "name": "BillingAddress", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCountry", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingPostalCode", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingState", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customer", + "description": "An object relationship", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceDate", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLines", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLines_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine", + "description": "columns and relationships of \"InvoiceLine\"", + "fields": [ + { + "name": "Invoice", + "description": "An object relationship", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Track", + "description": "An object relationship", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_aggregate", + "description": "aggregated selection of \"InvoiceLine\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_aggregate_bool_exp", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "count", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_aggregate_bool_exp_count", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_aggregate_bool_exp_count", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "arguments", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "filter", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "predicate", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_aggregate_fields", + "description": "aggregate fields of \"InvoiceLine\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_aggregate_order_by", + "description": "order by aggregate values of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "avg", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_avg_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "count", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "max", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_max_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "min", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_min_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stddev_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stddev_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stddev_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "sum", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_sum_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_var_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_var_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "variance", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_variance_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_arr_rel_insert_input", + "description": "input type for inserting array relation for remote table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_avg_order_by", + "description": "order by avg() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "description": "Boolean expression to filter rows from the table \"InvoiceLine\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "Invoice", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Track", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "numeric_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "InvoiceLine_constraint", + "description": "unique or primary key constraints on table \"InvoiceLine\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_InvoiceLine", + "description": "unique or primary key constraint on columns \"InvoiceLineId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_inc_input", + "description": "input type for incrementing numeric columns in table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_insert_input", + "description": "input type for inserting data into table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "Invoice", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Track", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_max_order_by", + "description": "order by max() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_min_order_by", + "description": "order by min() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_mutation_response", + "description": "response of any mutation on the table \"InvoiceLine\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_on_conflict", + "description": "on_conflict condition type for table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_order_by", + "description": "Ordering options when selecting data from \"InvoiceLine\".", + "fields": null, + "inputFields": [ + { + "name": "Invoice", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Track", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_pk_columns_input", + "description": "primary key columns input for table: InvoiceLine", + "fields": null, + "inputFields": [ + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "description": "select columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "InvoiceId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_set_input", + "description": "input type for updating data in table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stddev_order_by", + "description": "order by stddev() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stddev_pop_order_by", + "description": "order by stddev_pop() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stddev_samp_order_by", + "description": "order by stddev_samp() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stream_cursor_input", + "description": "Streaming cursor of the table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_sum_order_by", + "description": "order by sum() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "InvoiceLine_update_column", + "description": "update columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "InvoiceId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_var_pop_order_by", + "description": "order by var_pop() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_var_samp_order_by", + "description": "order by var_samp() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "InvoiceLine_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLineId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Quantity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_variance_order_by", + "description": "order by variance() on columns of table \"InvoiceLine\"", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Quantity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_aggregate", + "description": "aggregated selection of \"Invoice\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_aggregate_bool_exp", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "count", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_aggregate_bool_exp_count", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_aggregate_bool_exp_count", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "arguments", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "filter", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "predicate", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_aggregate_fields", + "description": "aggregate fields of \"Invoice\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Invoice_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_aggregate_order_by", + "description": "order by aggregate values of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "avg", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_avg_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "count", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "max", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_max_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "min", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_min_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_stddev_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_stddev_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_stddev_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "sum", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_sum_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_var_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_var_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "variance", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_variance_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_arr_rel_insert_input", + "description": "input type for inserting array relation for remote table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_avg_order_by", + "description": "order by avg() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "description": "Boolean expression to filter rows from the table \"Invoice\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "BillingAddress", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCity", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCountry", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingPostalCode", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingState", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Customer", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceDate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "timestamp_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLines", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLines_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "numeric_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Invoice_constraint", + "description": "unique or primary key constraints on table \"Invoice\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_Invoice", + "description": "unique or primary key constraint on columns \"InvoiceId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_inc_input", + "description": "input type for incrementing numeric columns in table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_insert_input", + "description": "input type for inserting data into table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "BillingAddress", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCity", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCountry", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingPostalCode", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingState", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Customer", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceDate", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLines", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "BillingAddress", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCountry", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingPostalCode", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingState", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceDate", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_max_order_by", + "description": "order by max() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "BillingAddress", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCountry", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingPostalCode", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingState", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceDate", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "BillingAddress", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCity", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCountry", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingPostalCode", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingState", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceDate", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_min_order_by", + "description": "order by min() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "BillingAddress", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCountry", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingPostalCode", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingState", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceDate", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_mutation_response", + "description": "response of any mutation on the table \"Invoice\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_obj_rel_insert_input", + "description": "input type for inserting object relation for remote table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_on_conflict", + "description": "on_conflict condition type for table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_order_by", + "description": "Ordering options when selecting data from \"Invoice\".", + "fields": null, + "inputFields": [ + { + "name": "BillingAddress", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCity", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCountry", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingPostalCode", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingState", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Customer", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceDate", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLines_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_pk_columns_input", + "description": "primary key columns input for table: Invoice", + "fields": null, + "inputFields": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Invoice_select_column", + "description": "select columns of table \"Invoice\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "BillingAddress", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCity", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCountry", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingPostalCode", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingState", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CustomerId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceDate", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_set_input", + "description": "input type for updating data in table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "BillingAddress", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCity", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCountry", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingPostalCode", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingState", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceDate", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_stddev_order_by", + "description": "order by stddev() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_stddev_pop_order_by", + "description": "order by stddev_pop() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_stddev_samp_order_by", + "description": "order by stddev_samp() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_stream_cursor_input", + "description": "Streaming cursor of the table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "BillingAddress", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCity", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingCountry", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingPostalCode", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "BillingState", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceDate", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_sum_order_by", + "description": "order by sum() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Invoice_update_column", + "description": "update columns of table \"Invoice\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "BillingAddress", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCity", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingCountry", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingPostalCode", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "BillingState", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CustomerId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceDate", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_var_pop_order_by", + "description": "order by var_pop() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_var_samp_order_by", + "description": "order by var_samp() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Invoice_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "CustomerId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Total", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Invoice_variance_order_by", + "description": "order by variance() on columns of table \"Invoice\"", + "fields": null, + "inputFields": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Total", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType", + "description": "columns and relationships of \"MediaType\"", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Tracks", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Tracks_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_aggregate", + "description": "aggregated selection of \"MediaType\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_aggregate_fields", + "description": "aggregate fields of \"MediaType\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "MediaType_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "MediaType_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "description": "Boolean expression to filter rows from the table \"MediaType\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "MediaType_constraint", + "description": "unique or primary key constraints on table \"MediaType\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_MediaType", + "description": "unique or primary key constraint on columns \"MediaTypeId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_insert_input", + "description": "input type for inserting data into table \"MediaType\"", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_mutation_response", + "description": "response of any mutation on the table \"MediaType\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_obj_rel_insert_input", + "description": "input type for inserting object relation for remote table \"MediaType\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_on_conflict", + "description": "on_conflict condition type for table \"MediaType\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "MediaType_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "MediaType_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_order_by", + "description": "Ordering options when selecting data from \"MediaType\".", + "fields": null, + "inputFields": [ + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Tracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_pk_columns_input", + "description": "primary key columns input for table: MediaType", + "fields": null, + "inputFields": [ + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "MediaType_select_column", + "description": "select columns of table \"MediaType\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "MediaTypeId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_set_input", + "description": "input type for updating data in table \"MediaType\"", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_stream_cursor_input", + "description": "Streaming cursor of the table \"MediaType\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "MediaType_update_column", + "description": "update columns of table \"MediaType\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "MediaType_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "MediaType_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist", + "description": "columns and relationships of \"Playlist\"", + "fields": [ + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTracks", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTracks_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack", + "description": "columns and relationships of \"PlaylistTrack\"", + "fields": [ + { + "name": "Playlist", + "description": "An object relationship", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Track", + "description": "An object relationship", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_aggregate", + "description": "aggregated selection of \"PlaylistTrack\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_aggregate_bool_exp", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "count", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_aggregate_bool_exp_count", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_aggregate_bool_exp_count", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "arguments", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "filter", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "predicate", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_aggregate_fields", + "description": "aggregate fields of \"PlaylistTrack\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_aggregate_order_by", + "description": "order by aggregate values of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "avg", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_avg_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "count", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "max", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_max_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "min", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_min_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stddev_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stddev_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stddev_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "sum", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_sum_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_var_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_var_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "variance", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_variance_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_arr_rel_insert_input", + "description": "input type for inserting array relation for remote table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_avg_order_by", + "description": "order by avg() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "description": "Boolean expression to filter rows from the table \"PlaylistTrack\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "Playlist", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Track", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "PlaylistTrack_constraint", + "description": "unique or primary key constraints on table \"PlaylistTrack\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_PlaylistTrack", + "description": "unique or primary key constraint on columns \"TrackId\", \"PlaylistId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_inc_input", + "description": "input type for incrementing numeric columns in table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_insert_input", + "description": "input type for inserting data into table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "Playlist", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Track", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_max_order_by", + "description": "order by max() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_min_order_by", + "description": "order by min() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_mutation_response", + "description": "response of any mutation on the table \"PlaylistTrack\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_on_conflict", + "description": "on_conflict condition type for table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_order_by", + "description": "Ordering options when selecting data from \"PlaylistTrack\".", + "fields": null, + "inputFields": [ + { + "name": "Playlist", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Track", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_pk_columns_input", + "description": "primary key columns input for table: PlaylistTrack", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "description": "select columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PlaylistId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_set_input", + "description": "input type for updating data in table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stddev_order_by", + "description": "order by stddev() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stddev_pop_order_by", + "description": "order by stddev_pop() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stddev_samp_order_by", + "description": "order by stddev_samp() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stream_cursor_input", + "description": "Streaming cursor of the table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_sum_order_by", + "description": "order by sum() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "PlaylistTrack_update_column", + "description": "update columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PlaylistId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_var_pop_order_by", + "description": "order by var_pop() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_var_samp_order_by", + "description": "order by var_samp() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlaylistTrack_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_variance_order_by", + "description": "order by variance() on columns of table \"PlaylistTrack\"", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_aggregate", + "description": "aggregated selection of \"Playlist\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_aggregate_fields", + "description": "aggregate fields of \"Playlist\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Playlist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Playlist_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "description": "Boolean expression to filter rows from the table \"Playlist\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistTracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistTracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Playlist_constraint", + "description": "unique or primary key constraints on table \"Playlist\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_Playlist", + "description": "unique or primary key constraint on columns \"PlaylistId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_insert_input", + "description": "input type for inserting data into table \"Playlist\"", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistTracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_mutation_response", + "description": "response of any mutation on the table \"Playlist\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_obj_rel_insert_input", + "description": "input type for inserting object relation for remote table \"Playlist\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_on_conflict", + "description": "on_conflict condition type for table \"Playlist\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Playlist_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Playlist_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_order_by", + "description": "Ordering options when selecting data from \"Playlist\".", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistTracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_pk_columns_input", + "description": "primary key columns input for table: Playlist", + "fields": null, + "inputFields": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Playlist_select_column", + "description": "select columns of table \"Playlist\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_set_input", + "description": "input type for updating data in table \"Playlist\"", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_stream_cursor_input", + "description": "Streaming cursor of the table \"Playlist\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Playlist_update_column", + "description": "update columns of table \"Playlist\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Playlist_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Playlist_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "PlaylistId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "String", + "description": null, + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "description": "Boolean expression to compare columns of type \"String\". All fields are combined with logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "_eq", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_gt", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_gte", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_ilike", + "description": "does the column match the given case-insensitive pattern", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_in", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_iregex", + "description": "does the column match the given POSIX regular expression, case insensitive", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_is_null", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_like", + "description": "does the column match the given pattern", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_lt", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_lte", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_neq", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_nilike", + "description": "does the column NOT match the given case-insensitive pattern", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_nin", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_niregex", + "description": "does the column NOT match the given POSIX regular expression, case insensitive", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_nlike", + "description": "does the column NOT match the given pattern", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_nregex", + "description": "does the column NOT match the given POSIX regular expression, case sensitive", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_nsimilar", + "description": "does the column NOT match the given SQL regular expression", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_regex", + "description": "does the column match the given POSIX regular expression, case sensitive", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_similar", + "description": "does the column match the given SQL regular expression", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track", + "description": "columns and relationships of \"Track\"", + "fields": [ + { + "name": "Album", + "description": "An object relationship", + "args": [], + "type": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Composer", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Genre", + "description": "An object relationship", + "args": [], + "type": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLines", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLines_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaType", + "description": "An object relationship", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTracks", + "description": "An array relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTracks_aggregate", + "description": "An aggregate relationship", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_aggregate", + "description": "aggregated selection of \"Track\"", + "fields": [ + { + "name": "aggregate", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_aggregate_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nodes", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_bool_exp", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "count", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_bool_exp_count", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_bool_exp_count", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "arguments", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "filter", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "predicate", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_aggregate_fields", + "description": "aggregate fields of \"Track\"", + "fields": [ + { + "name": "avg", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_avg_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "count", + "description": null, + "args": [ + { + "name": "columns", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "distinct", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_max_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "min", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_min_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_stddev_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_stddev_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stddev_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_stddev_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sum", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_sum_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_pop", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_var_pop_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "var_samp", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_var_samp_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "variance", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Track_variance_fields", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_aggregate_order_by", + "description": "order by aggregate values of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "avg", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_avg_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "count", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "max", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_max_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "min", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_min_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_stddev_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_stddev_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "stddev_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_stddev_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "sum", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_sum_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_pop", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_var_pop_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "var_samp", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_var_samp_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "variance", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_variance_order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_arr_rel_insert_input", + "description": "input type for inserting array relation for remote table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_avg_fields", + "description": "aggregate avg on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_avg_order_by", + "description": "order by avg() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "description": "Boolean expression to filter rows from the table \"Track\". All fields are combined with a logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "Album", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Composer", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Genre", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLines", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLines_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaType", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "String_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistTracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistTracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_aggregate_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Int_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "numeric_comparison_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_and", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_not", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_or", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Track_constraint", + "description": "unique or primary key constraints on table \"Track\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "PK_Track", + "description": "unique or primary key constraint on columns \"TrackId\"", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_inc_input", + "description": "input type for incrementing numeric columns in table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_insert_input", + "description": "input type for inserting data into table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "Album", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Composer", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Genre", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLines", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaType", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_obj_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistTracks", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_arr_rel_insert_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_max_fields", + "description": "aggregate max on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Composer", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_max_order_by", + "description": "order by max() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Composer", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_min_fields", + "description": "aggregate min on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Composer", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_min_order_by", + "description": "order by min() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Composer", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_mutation_response", + "description": "response of any mutation on the table \"Track\"", + "fields": [ + { + "name": "affected_rows", + "description": "number of rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "returning", + "description": "data from the rows affected by the mutation", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_obj_rel_insert_input", + "description": "input type for inserting object relation for remote table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "data", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_on_conflict", + "description": "on_conflict condition type for table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "constraint", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_constraint", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "update_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_update_column", + "ofType": null + } + } + } + }, + "defaultValue": "[]" + }, + { + "name": "where", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "description": "Ordering options when selecting data from \"Track\".", + "fields": null, + "inputFields": [ + { + "name": "Album", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Composer", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Genre", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "InvoiceLines_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaType", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "PlaylistTracks_aggregate", + "description": null, + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_aggregate_order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_pk_columns_input", + "description": "primary key columns input for table: Track", + "fields": null, + "inputFields": [ + { + "name": "TrackId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Track_select_column", + "description": "select columns of table \"Track\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "AlbumId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Composer", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_set_input", + "description": "input type for updating data in table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Composer", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_stddev_fields", + "description": "aggregate stddev on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_stddev_order_by", + "description": "order by stddev() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_stddev_pop_fields", + "description": "aggregate stddev_pop on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_stddev_pop_order_by", + "description": "order by stddev_pop() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_stddev_samp_fields", + "description": "aggregate stddev_samp on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_stddev_samp_order_by", + "description": "order by stddev_samp() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_stream_cursor_input", + "description": "Streaming cursor of the table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "initial_value", + "description": "Stream column input with initial value", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_stream_cursor_value_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "ordering", + "description": "cursor ordering", + "type": { + "kind": "ENUM", + "name": "cursor_ordering", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_stream_cursor_value_input", + "description": "Initial value of the column from where the streaming should start", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Composer", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Name", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_sum_fields", + "description": "aggregate sum on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_sum_order_by", + "description": "order by sum() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "Track_update_column", + "description": "update columns of table \"Track\"", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "AlbumId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Composer", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Name", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": "column name", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_updates", + "description": null, + "fields": null, + "inputFields": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_var_pop_fields", + "description": "aggregate var_pop on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_var_pop_order_by", + "description": "order by var_pop() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_var_samp_fields", + "description": "aggregate var_samp on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_var_samp_order_by", + "description": "order by var_samp() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Track_variance_fields", + "description": "aggregate variance on columns", + "fields": [ + { + "name": "AlbumId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Bytes", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GenreId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaTypeId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Milliseconds", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "TrackId", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UnitPrice", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "Track_variance_order_by", + "description": "order by variance() on columns of table \"Track\"", + "fields": null, + "inputFields": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Bytes", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "GenreId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "Milliseconds", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "UnitPrice", + "description": null, + "type": { + "kind": "ENUM", + "name": "order_by", + "ofType": null + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__Directive", + "description": null, + "fields": [ + { + "name": "args", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__InputValue", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "isRepeatable", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "locations", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__EnumValue", + "description": null, + "fields": [ + { + "name": "deprecationReason", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "isDeprecated", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__Field", + "description": null, + "fields": [ + { + "name": "args", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__InputValue", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "deprecationReason", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "isDeprecated", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "type", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__InputValue", + "description": null, + "fields": [ + { + "name": "defaultValue", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "type", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__Schema", + "description": null, + "fields": [ + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "directives", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Directive", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "mutationType", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "queryType", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "subscriptionType", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "types", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__Type", + "description": null, + "fields": [ + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "enumValues", + "description": null, + "args": [ + { + "name": "includeDeprecated", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + } + ], + "type": { + "kind": "OBJECT", + "name": "__EnumValue", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "fields", + "description": null, + "args": [ + { + "name": "includeDeprecated", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + } + ], + "type": { + "kind": "OBJECT", + "name": "__Field", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "inputFields", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__InputValue", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "interfaces", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "kind", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "__TypeKind", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ofType", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "possibleTypes", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "__TypeKind", + "description": null, + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "ENUM", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "INPUT_OBJECT", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "INTERFACE", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LIST", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "NON_NULL", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "OBJECT", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SCALAR", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UNION", + "description": null, + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "cursor_ordering", + "description": "ordering argument of a cursor", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "ASC", + "description": "ascending ordering of the cursor", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "DESC", + "description": "descending ordering of the cursor", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "mutation_root", + "description": "mutation root", + "fields": [ + { + "name": "delete_Album", + "description": "delete data from the table: \"Album\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Album_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Album_by_pk", + "description": "delete single row from the table: \"Album\"", + "args": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Artist", + "description": "delete data from the table: \"Artist\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Artist_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Artist_by_pk", + "description": "delete single row from the table: \"Artist\"", + "args": [ + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Customer", + "description": "delete data from the table: \"Customer\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Customer_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Customer_by_pk", + "description": "delete single row from the table: \"Customer\"", + "args": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Employee", + "description": "delete data from the table: \"Employee\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Employee_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Employee_by_pk", + "description": "delete single row from the table: \"Employee\"", + "args": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Genre", + "description": "delete data from the table: \"Genre\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Genre_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Genre_by_pk", + "description": "delete single row from the table: \"Genre\"", + "args": [ + { + "name": "GenreId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Invoice", + "description": "delete data from the table: \"Invoice\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Invoice_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_InvoiceLine", + "description": "delete data from the table: \"InvoiceLine\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_InvoiceLine_by_pk", + "description": "delete single row from the table: \"InvoiceLine\"", + "args": [ + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Invoice_by_pk", + "description": "delete single row from the table: \"Invoice\"", + "args": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_MediaType", + "description": "delete data from the table: \"MediaType\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "MediaType_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_MediaType_by_pk", + "description": "delete single row from the table: \"MediaType\"", + "args": [ + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Playlist", + "description": "delete data from the table: \"Playlist\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Playlist_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_PlaylistTrack", + "description": "delete data from the table: \"PlaylistTrack\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_PlaylistTrack_by_pk", + "description": "delete single row from the table: \"PlaylistTrack\"", + "args": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Playlist_by_pk", + "description": "delete single row from the table: \"Playlist\"", + "args": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Track", + "description": "delete data from the table: \"Track\"", + "args": [ + { + "name": "where", + "description": "filter the rows which have to be deleted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Track_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "delete_Track_by_pk", + "description": "delete single row from the table: \"Track\"", + "args": [ + { + "name": "TrackId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Album", + "description": "insert data into the table: \"Album\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Album_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Album_one", + "description": "insert a single row into the table: \"Album\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Artist", + "description": "insert data into the table: \"Artist\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Artist_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Artist_one", + "description": "insert a single row into the table: \"Artist\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Customer", + "description": "insert data into the table: \"Customer\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Customer_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Customer_one", + "description": "insert a single row into the table: \"Customer\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Employee", + "description": "insert data into the table: \"Employee\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Employee_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Employee_one", + "description": "insert a single row into the table: \"Employee\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Genre", + "description": "insert data into the table: \"Genre\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Genre_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Genre_one", + "description": "insert a single row into the table: \"Genre\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Invoice", + "description": "insert data into the table: \"Invoice\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Invoice_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_InvoiceLine", + "description": "insert data into the table: \"InvoiceLine\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_InvoiceLine_one", + "description": "insert a single row into the table: \"InvoiceLine\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Invoice_one", + "description": "insert a single row into the table: \"Invoice\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_MediaType", + "description": "insert data into the table: \"MediaType\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "MediaType_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_MediaType_one", + "description": "insert a single row into the table: \"MediaType\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Playlist", + "description": "insert data into the table: \"Playlist\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Playlist_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_PlaylistTrack", + "description": "insert data into the table: \"PlaylistTrack\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_PlaylistTrack_one", + "description": "insert a single row into the table: \"PlaylistTrack\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Playlist_one", + "description": "insert a single row into the table: \"Playlist\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Track", + "description": "insert data into the table: \"Track\"", + "args": [ + { + "name": "objects", + "description": "the rows to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_insert_input", + "ofType": null + } + } + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Track_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "insert_Track_one", + "description": "insert a single row into the table: \"Track\"", + "args": [ + { + "name": "object", + "description": "the row to be inserted", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_insert_input", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "on_conflict", + "description": "upsert condition", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_on_conflict", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Album", + "description": "update data of the table: \"Album\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Album_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Album_by_pk", + "description": "update single row of the table: \"Album\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Album_many", + "description": "update multiples rows of table: \"Album\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Artist", + "description": "update data of the table: \"Artist\"", + "args": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Artist_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Artist_by_pk", + "description": "update single row of the table: \"Artist\"", + "args": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Artist_many", + "description": "update multiples rows of table: \"Artist\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Artist_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Customer", + "description": "update data of the table: \"Customer\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Customer_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Customer_by_pk", + "description": "update single row of the table: \"Customer\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Customer_many", + "description": "update multiples rows of table: \"Customer\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Employee", + "description": "update data of the table: \"Employee\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Employee_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Employee_by_pk", + "description": "update single row of the table: \"Employee\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Employee_many", + "description": "update multiples rows of table: \"Employee\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Genre", + "description": "update data of the table: \"Genre\"", + "args": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Genre_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Genre_by_pk", + "description": "update single row of the table: \"Genre\"", + "args": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Genre_many", + "description": "update multiples rows of table: \"Genre\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Genre_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Invoice", + "description": "update data of the table: \"Invoice\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Invoice_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_InvoiceLine", + "description": "update data of the table: \"InvoiceLine\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_InvoiceLine_by_pk", + "description": "update single row of the table: \"InvoiceLine\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_InvoiceLine_many", + "description": "update multiples rows of table: \"InvoiceLine\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Invoice_by_pk", + "description": "update single row of the table: \"Invoice\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Invoice_many", + "description": "update multiples rows of table: \"Invoice\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_MediaType", + "description": "update data of the table: \"MediaType\"", + "args": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "MediaType_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_MediaType_by_pk", + "description": "update single row of the table: \"MediaType\"", + "args": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_MediaType_many", + "description": "update multiples rows of table: \"MediaType\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "MediaType_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Playlist", + "description": "update data of the table: \"Playlist\"", + "args": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Playlist_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_PlaylistTrack", + "description": "update data of the table: \"PlaylistTrack\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_PlaylistTrack_by_pk", + "description": "update single row of the table: \"PlaylistTrack\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_PlaylistTrack_many", + "description": "update multiples rows of table: \"PlaylistTrack\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Playlist_by_pk", + "description": "update single row of the table: \"Playlist\"", + "args": [ + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Playlist_many", + "description": "update multiples rows of table: \"Playlist\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Playlist_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Track", + "description": "update data of the table: \"Track\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows which have to be updated", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Track_mutation_response", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Track_by_pk", + "description": "update single row of the table: \"Track\"", + "args": [ + { + "name": "_inc", + "description": "increments the numeric columns with given value of the filtered values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_inc_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_set", + "description": "sets the columns of the filtered rows to the given values", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_set_input", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pk_columns", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_pk_columns_input", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "update_Track_many", + "description": "update multiples rows of table: \"Track\"", + "args": [ + { + "name": "updates", + "description": "updates to execute, in order", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_updates", + "ofType": null + } + } + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track_mutation_response", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "numeric", + "description": null, + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "numeric_comparison_exp", + "description": "Boolean expression to compare columns of type \"numeric\". All fields are combined with logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "_eq", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_gt", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_gte", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_in", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_is_null", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_lt", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_lte", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_neq", + "description": null, + "type": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_nin", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "numeric", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "order_by", + "description": "column ordering options", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "asc", + "description": "in ascending order, nulls last", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "asc_nulls_first", + "description": "in ascending order, nulls first", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "asc_nulls_last", + "description": "in ascending order, nulls last", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "desc", + "description": "in descending order, nulls first", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "desc_nulls_first", + "description": "in descending order, nulls first", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "desc_nulls_last", + "description": "in descending order, nulls last", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "query_root", + "description": null, + "fields": [ + { + "name": "Album", + "description": "fetch data from the table: \"Album\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Album_aggregate", + "description": "fetch aggregated fields from the table: \"Album\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Album_by_pk", + "description": "fetch data from the table: \"Album\" using primary key columns", + "args": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Artist", + "description": "fetch data from the table: \"Artist\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Artist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Artist_aggregate", + "description": "fetch aggregated fields from the table: \"Artist\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Artist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Artist_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Artist_by_pk", + "description": "fetch data from the table: \"Artist\" using primary key columns", + "args": [ + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customer", + "description": "fetch data from the table: \"Customer\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customer_aggregate", + "description": "fetch aggregated fields from the table: \"Customer\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customer_by_pk", + "description": "fetch data from the table: \"Customer\" using primary key columns", + "args": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employee", + "description": "fetch data from the table: \"Employee\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employee_aggregate", + "description": "fetch aggregated fields from the table: \"Employee\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employee_by_pk", + "description": "fetch data from the table: \"Employee\" using primary key columns", + "args": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Genre", + "description": "fetch data from the table: \"Genre\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Genre_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Genre_aggregate", + "description": "fetch aggregated fields from the table: \"Genre\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Genre_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Genre_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Genre_by_pk", + "description": "fetch data from the table: \"Genre\" using primary key columns", + "args": [ + { + "name": "GenreId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Invoice", + "description": "fetch data from the table: \"Invoice\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLine", + "description": "fetch data from the table: \"InvoiceLine\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLine_aggregate", + "description": "fetch aggregated fields from the table: \"InvoiceLine\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLine_by_pk", + "description": "fetch data from the table: \"InvoiceLine\" using primary key columns", + "args": [ + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Invoice_aggregate", + "description": "fetch aggregated fields from the table: \"Invoice\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Invoice_by_pk", + "description": "fetch data from the table: \"Invoice\" using primary key columns", + "args": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaType", + "description": "fetch data from the table: \"MediaType\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "MediaType_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaType_aggregate", + "description": "fetch aggregated fields from the table: \"MediaType\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "MediaType_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "MediaType_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaType_by_pk", + "description": "fetch data from the table: \"MediaType\" using primary key columns", + "args": [ + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Playlist", + "description": "fetch data from the table: \"Playlist\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Playlist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTrack", + "description": "fetch data from the table: \"PlaylistTrack\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTrack_aggregate", + "description": "fetch aggregated fields from the table: \"PlaylistTrack\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTrack_by_pk", + "description": "fetch data from the table: \"PlaylistTrack\" using primary key columns", + "args": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Playlist_aggregate", + "description": "fetch aggregated fields from the table: \"Playlist\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Playlist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Playlist_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Playlist_by_pk", + "description": "fetch data from the table: \"Playlist\" using primary key columns", + "args": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Track", + "description": "fetch data from the table: \"Track\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Track_aggregate", + "description": "fetch aggregated fields from the table: \"Track\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Track_by_pk", + "description": "fetch data from the table: \"Track\" using primary key columns", + "args": [ + { + "name": "TrackId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "subscription_root", + "description": null, + "fields": [ + { + "name": "Album", + "description": "fetch data from the table: \"Album\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Album_aggregate", + "description": "fetch aggregated fields from the table: \"Album\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Album_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Album_by_pk", + "description": "fetch data from the table: \"Album\" using primary key columns", + "args": [ + { + "name": "AlbumId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Album_stream", + "description": "fetch data from the table in a streaming manner: \"Album\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Album_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Album_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Album", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Artist", + "description": "fetch data from the table: \"Artist\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Artist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Artist_aggregate", + "description": "fetch aggregated fields from the table: \"Artist\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Artist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Artist_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Artist_by_pk", + "description": "fetch data from the table: \"Artist\" using primary key columns", + "args": [ + { + "name": "ArtistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Artist_stream", + "description": "fetch data from the table in a streaming manner: \"Artist\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Artist_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Artist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Artist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customer", + "description": "fetch data from the table: \"Customer\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customer_aggregate", + "description": "fetch aggregated fields from the table: \"Customer\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Customer_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customer_by_pk", + "description": "fetch data from the table: \"Customer\" using primary key columns", + "args": [ + { + "name": "CustomerId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Customer_stream", + "description": "fetch data from the table in a streaming manner: \"Customer\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Customer_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Customer_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Customer", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employee", + "description": "fetch data from the table: \"Employee\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employee_aggregate", + "description": "fetch aggregated fields from the table: \"Employee\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Employee_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employee_by_pk", + "description": "fetch data from the table: \"Employee\" using primary key columns", + "args": [ + { + "name": "EmployeeId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Employee_stream", + "description": "fetch data from the table in a streaming manner: \"Employee\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Employee_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Employee_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Employee", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Genre", + "description": "fetch data from the table: \"Genre\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Genre_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Genre_aggregate", + "description": "fetch aggregated fields from the table: \"Genre\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Genre_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Genre_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Genre_by_pk", + "description": "fetch data from the table: \"Genre\" using primary key columns", + "args": [ + { + "name": "GenreId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Genre_stream", + "description": "fetch data from the table in a streaming manner: \"Genre\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Genre_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Genre_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Genre", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Invoice", + "description": "fetch data from the table: \"Invoice\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLine", + "description": "fetch data from the table: \"InvoiceLine\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLine_aggregate", + "description": "fetch aggregated fields from the table: \"InvoiceLine\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "InvoiceLine_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLine_by_pk", + "description": "fetch data from the table: \"InvoiceLine\" using primary key columns", + "args": [ + { + "name": "InvoiceLineId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "InvoiceLine_stream", + "description": "fetch data from the table in a streaming manner: \"InvoiceLine\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "InvoiceLine_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "InvoiceLine", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Invoice_aggregate", + "description": "fetch aggregated fields from the table: \"Invoice\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Invoice_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Invoice_by_pk", + "description": "fetch data from the table: \"Invoice\" using primary key columns", + "args": [ + { + "name": "InvoiceId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Invoice_stream", + "description": "fetch data from the table in a streaming manner: \"Invoice\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Invoice_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Invoice_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Invoice", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaType", + "description": "fetch data from the table: \"MediaType\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "MediaType_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaType_aggregate", + "description": "fetch aggregated fields from the table: \"MediaType\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "MediaType_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "MediaType_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaType_by_pk", + "description": "fetch data from the table: \"MediaType\" using primary key columns", + "args": [ + { + "name": "MediaTypeId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MediaType_stream", + "description": "fetch data from the table in a streaming manner: \"MediaType\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "MediaType_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "MediaType_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "MediaType", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Playlist", + "description": "fetch data from the table: \"Playlist\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Playlist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTrack", + "description": "fetch data from the table: \"PlaylistTrack\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTrack_aggregate", + "description": "fetch aggregated fields from the table: \"PlaylistTrack\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "PlaylistTrack_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTrack_by_pk", + "description": "fetch data from the table: \"PlaylistTrack\" using primary key columns", + "args": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "TrackId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "PlaylistTrack_stream", + "description": "fetch data from the table in a streaming manner: \"PlaylistTrack\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "PlaylistTrack_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlaylistTrack", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Playlist_aggregate", + "description": "fetch aggregated fields from the table: \"Playlist\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Playlist_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Playlist_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Playlist_by_pk", + "description": "fetch data from the table: \"Playlist\" using primary key columns", + "args": [ + { + "name": "PlaylistId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Playlist_stream", + "description": "fetch data from the table in a streaming manner: \"Playlist\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Playlist_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Playlist_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Playlist", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Track", + "description": "fetch data from the table: \"Track\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Track_aggregate", + "description": "fetch aggregated fields from the table: \"Track\"", + "args": [ + { + "name": "distinct_on", + "description": "distinct select on columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "Track_select_column", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "limit the number of rows returned", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "offset", + "description": "skip the first n rows. Use only with order_by", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "order_by", + "description": "sort the rows by one or more columns", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_order_by", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track_aggregate", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Track_by_pk", + "description": "fetch data from the table: \"Track\" using primary key columns", + "args": [ + { + "name": "TrackId", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Track_stream", + "description": "fetch data from the table in a streaming manner: \"Track\"", + "args": [ + { + "name": "batch_size", + "description": "maximum number of rows returned in a single batch", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + }, + { + "name": "cursor", + "description": "cursor to stream the results returned by the query", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "INPUT_OBJECT", + "name": "Track_stream_cursor_input", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "where", + "description": "filter the rows returned", + "type": { + "kind": "INPUT_OBJECT", + "name": "Track_bool_exp", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Track", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "timestamp", + "description": null, + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + "name": "timestamp_comparison_exp", + "description": "Boolean expression to compare columns of type \"timestamp\". All fields are combined with logical 'AND'.", + "fields": null, + "inputFields": [ + { + "name": "_eq", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_gt", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_gte", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_in", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + } + } + }, + "defaultValue": null + }, + { + "name": "_is_null", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_lt", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_lte", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_neq", + "description": null, + "type": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "_nin", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "timestamp", + "ofType": null + } + } + }, + "defaultValue": null + } + ], + "interfaces": null, + "enumValues": null, + "possibleTypes": null + } + ], + "directives": [ + { + "name": "include", + "description": "whether this query should be included", + "locations": [ + "FIELD", + "FRAGMENT_SPREAD", + "INLINE_FRAGMENT" + ], + "args": [ + { + "name": "if", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "defaultValue": null + } + ] + }, + { + "name": "skip", + "description": "whether this query should be skipped", + "locations": [ + "FIELD", + "FRAGMENT_SPREAD", + "INLINE_FRAGMENT" + ], + "args": [ + { + "name": "if", + "description": null, + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "defaultValue": null + } + ] + }, + { + "name": "cached", + "description": "whether this query should be cached (Hasura Cloud only)", + "locations": [ + "QUERY" + ], + "args": [ + { + "name": "ttl", + "description": "measured in seconds", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": "60" + }, + { + "name": "refresh", + "description": "refresh the cache entry", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "defaultValue": "false" + } + ] + } + ] + } + } +} \ No newline at end of file diff --git a/crates/ndc-graphql-cli/tests/introspection.rs b/crates/ndc-graphql-cli/tests/introspection.rs new file mode 100644 index 0000000..89dd468 --- /dev/null +++ b/crates/ndc-graphql-cli/tests/introspection.rs @@ -0,0 +1,21 @@ +use insta::assert_snapshot; +use ndc_graphql_cli::graphql::{introspection::Introspection, schema_from_introspection}; +use std::{error::Error, path::PathBuf}; +use tokio::fs; + +#[tokio::test] +async fn generate_schema_from_introspection() -> Result<(), Box> { + let introspection_response_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("tests") + .join("introspection.json"); + let introspection_file = fs::read_to_string(introspection_response_path).await?; + let introspection_response: graphql_client::Response = + serde_json::from_str(&introspection_file)?; + let introspection_data = introspection_response + .data + .expect("introspection test file should have data"); + let graphql_sdl = schema_from_introspection(introspection_data); + assert_snapshot!(graphql_sdl.to_string()); + + Ok(()) +} diff --git a/crates/ndc-graphql-cli/tests/snapshots/introspection__generate_schema_from_introspection.snap b/crates/ndc-graphql-cli/tests/snapshots/introspection__generate_schema_from_introspection.snap new file mode 100644 index 0000000..dcf2cb8 --- /dev/null +++ b/crates/ndc-graphql-cli/tests/snapshots/introspection__generate_schema_from_introspection.snap @@ -0,0 +1,3754 @@ +--- +source: crates/ndc-graphql-cli/tests/introspection.rs +expression: graphql_sdl.to_string() +--- +schema { + query: query_root + mutation: mutation_root + subscription: subscription_root +} + +"columns and relationships of \"Album\"" +type Album { + AlbumId: Int! + "An object relationship" + Artist: Artist! + ArtistId: Int! + Title: String! + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"Album\"" +type Album_aggregate { + aggregate: Album_aggregate_fields + nodes: [Album!]! +} + +input Album_aggregate_bool_exp { + count: Album_aggregate_bool_exp_count +} + +input Album_aggregate_bool_exp_count { + arguments: [Album_select_column!] + distinct: Boolean + filter: Album_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Album\"" +type Album_aggregate_fields { + avg: Album_avg_fields + count(columns: [Album_select_column!], distinct: Boolean): Int! + max: Album_max_fields + min: Album_min_fields + stddev: Album_stddev_fields + stddev_pop: Album_stddev_pop_fields + stddev_samp: Album_stddev_samp_fields + sum: Album_sum_fields + var_pop: Album_var_pop_fields + var_samp: Album_var_samp_fields + variance: Album_variance_fields +} + +"order by aggregate values of table \"Album\"" +input Album_aggregate_order_by { + avg: Album_avg_order_by + count: order_by + max: Album_max_order_by + min: Album_min_order_by + stddev: Album_stddev_order_by + stddev_pop: Album_stddev_pop_order_by + stddev_samp: Album_stddev_samp_order_by + sum: Album_sum_order_by + var_pop: Album_var_pop_order_by + var_samp: Album_var_samp_order_by + variance: Album_variance_order_by +} + +"input type for inserting array relation for remote table \"Album\"" +input Album_arr_rel_insert_input { + data: [Album_insert_input!]! + "upsert condition" on_conflict: Album_on_conflict +} + +"aggregate avg on columns" +type Album_avg_fields { + AlbumId: Float + ArtistId: Float +} + +"order by avg() on columns of table \"Album\"" +input Album_avg_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"Boolean expression to filter rows from the table \"Album\". All fields are combined with a logical 'AND'." +input Album_bool_exp { + AlbumId: Int_comparison_exp + Artist: Artist_bool_exp + ArtistId: Int_comparison_exp + Title: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [Album_bool_exp!] + _not: Album_bool_exp + _or: [Album_bool_exp!] +} + +"unique or primary key constraints on table \"Album\"" +enum Album_constraint { + "unique or primary key constraint on columns \"AlbumId\"" PK_Album +} + +"input type for incrementing numeric columns in table \"Album\"" +input Album_inc_input { + ArtistId: Int +} + +"input type for inserting data into table \"Album\"" +input Album_insert_input { + Artist: Artist_obj_rel_insert_input + ArtistId: Int + Title: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type Album_max_fields { + AlbumId: Int + ArtistId: Int + Title: String +} + +"order by max() on columns of table \"Album\"" +input Album_max_order_by { + AlbumId: order_by + ArtistId: order_by + Title: order_by +} + +"aggregate min on columns" +type Album_min_fields { + AlbumId: Int + ArtistId: Int + Title: String +} + +"order by min() on columns of table \"Album\"" +input Album_min_order_by { + AlbumId: order_by + ArtistId: order_by + Title: order_by +} + +"response of any mutation on the table \"Album\"" +type Album_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Album!]! +} + +"input type for inserting object relation for remote table \"Album\"" +input Album_obj_rel_insert_input { + data: Album_insert_input! + "upsert condition" on_conflict: Album_on_conflict +} + +"on_conflict condition type for table \"Album\"" +input Album_on_conflict { + constraint: Album_constraint! + update_columns: [Album_update_column!]! = [] + where: Album_bool_exp +} + +"Ordering options when selecting data from \"Album\"." +input Album_order_by { + AlbumId: order_by + Artist: Artist_order_by + ArtistId: order_by + Title: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: Album" +input Album_pk_columns_input { + AlbumId: Int! +} + +"select columns of table \"Album\"" +enum Album_select_column { + "column name" AlbumId + "column name" ArtistId + "column name" Title +} + +"input type for updating data in table \"Album\"" +input Album_set_input { + ArtistId: Int + Title: String +} + +"aggregate stddev on columns" +type Album_stddev_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev() on columns of table \"Album\"" +input Album_stddev_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate stddev_pop on columns" +type Album_stddev_pop_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev_pop() on columns of table \"Album\"" +input Album_stddev_pop_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate stddev_samp on columns" +type Album_stddev_samp_fields { + AlbumId: Float + ArtistId: Float +} + +"order by stddev_samp() on columns of table \"Album\"" +input Album_stddev_samp_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"Streaming cursor of the table \"Album\"" +input Album_stream_cursor_input { + "Stream column input with initial value" initial_value: Album_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Album_stream_cursor_value_input { + AlbumId: Int + ArtistId: Int + Title: String +} + +"aggregate sum on columns" +type Album_sum_fields { + AlbumId: Int + ArtistId: Int +} + +"order by sum() on columns of table \"Album\"" +input Album_sum_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"update columns of table \"Album\"" +enum Album_update_column { + "column name" ArtistId + "column name" Title +} + +input Album_updates { + "increments the numeric columns with given value of the filtered values" _inc: Album_inc_input + "sets the columns of the filtered rows to the given values" _set: Album_set_input + "filter the rows which have to be updated" where: Album_bool_exp! +} + +"aggregate var_pop on columns" +type Album_var_pop_fields { + AlbumId: Float + ArtistId: Float +} + +"order by var_pop() on columns of table \"Album\"" +input Album_var_pop_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate var_samp on columns" +type Album_var_samp_fields { + AlbumId: Float + ArtistId: Float +} + +"order by var_samp() on columns of table \"Album\"" +input Album_var_samp_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"aggregate variance on columns" +type Album_variance_fields { + AlbumId: Float + ArtistId: Float +} + +"order by variance() on columns of table \"Album\"" +input Album_variance_order_by { + AlbumId: order_by + ArtistId: order_by +} + +"columns and relationships of \"Artist\"" +type Artist { + "An array relationship" + Albums("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "An aggregate relationship" + Albums_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + ArtistId: Int! + Name: String +} + +"aggregated selection of \"Artist\"" +type Artist_aggregate { + aggregate: Artist_aggregate_fields + nodes: [Artist!]! +} + +"aggregate fields of \"Artist\"" +type Artist_aggregate_fields { + avg: Artist_avg_fields + count(columns: [Artist_select_column!], distinct: Boolean): Int! + max: Artist_max_fields + min: Artist_min_fields + stddev: Artist_stddev_fields + stddev_pop: Artist_stddev_pop_fields + stddev_samp: Artist_stddev_samp_fields + sum: Artist_sum_fields + var_pop: Artist_var_pop_fields + var_samp: Artist_var_samp_fields + variance: Artist_variance_fields +} + +"aggregate avg on columns" +type Artist_avg_fields { + ArtistId: Float +} + +"Boolean expression to filter rows from the table \"Artist\". All fields are combined with a logical 'AND'." +input Artist_bool_exp { + Albums: Album_bool_exp + Albums_aggregate: Album_aggregate_bool_exp + ArtistId: Int_comparison_exp + Name: String_comparison_exp + _and: [Artist_bool_exp!] + _not: Artist_bool_exp + _or: [Artist_bool_exp!] +} + +"unique or primary key constraints on table \"Artist\"" +enum Artist_constraint { + "unique or primary key constraint on columns \"ArtistId\"" PK_Artist +} + +"input type for inserting data into table \"Artist\"" +input Artist_insert_input { + Albums: Album_arr_rel_insert_input + Name: String +} + +"aggregate max on columns" +type Artist_max_fields { + ArtistId: Int + Name: String +} + +"aggregate min on columns" +type Artist_min_fields { + ArtistId: Int + Name: String +} + +"response of any mutation on the table \"Artist\"" +type Artist_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Artist!]! +} + +"input type for inserting object relation for remote table \"Artist\"" +input Artist_obj_rel_insert_input { + data: Artist_insert_input! + "upsert condition" on_conflict: Artist_on_conflict +} + +"on_conflict condition type for table \"Artist\"" +input Artist_on_conflict { + constraint: Artist_constraint! + update_columns: [Artist_update_column!]! = [] + where: Artist_bool_exp +} + +"Ordering options when selecting data from \"Artist\"." +input Artist_order_by { + Albums_aggregate: Album_aggregate_order_by + ArtistId: order_by + Name: order_by +} + +"primary key columns input for table: Artist" +input Artist_pk_columns_input { + ArtistId: Int! +} + +"select columns of table \"Artist\"" +enum Artist_select_column { + "column name" ArtistId + "column name" Name +} + +"input type for updating data in table \"Artist\"" +input Artist_set_input { + Name: String +} + +"aggregate stddev on columns" +type Artist_stddev_fields { + ArtistId: Float +} + +"aggregate stddev_pop on columns" +type Artist_stddev_pop_fields { + ArtistId: Float +} + +"aggregate stddev_samp on columns" +type Artist_stddev_samp_fields { + ArtistId: Float +} + +"Streaming cursor of the table \"Artist\"" +input Artist_stream_cursor_input { + "Stream column input with initial value" initial_value: Artist_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Artist_stream_cursor_value_input { + ArtistId: Int + Name: String +} + +"aggregate sum on columns" +type Artist_sum_fields { + ArtistId: Int +} + +"update columns of table \"Artist\"" +enum Artist_update_column { + "column name" Name +} + +input Artist_updates { + "sets the columns of the filtered rows to the given values" _set: Artist_set_input + "filter the rows which have to be updated" where: Artist_bool_exp! +} + +"aggregate var_pop on columns" +type Artist_var_pop_fields { + ArtistId: Float +} + +"aggregate var_samp on columns" +type Artist_var_samp_fields { + ArtistId: Float +} + +"aggregate variance on columns" +type Artist_variance_fields { + ArtistId: Float +} + +scalar Boolean + +"columns and relationships of \"Customer\"" +type Customer { + Address: String + City: String + Company: String + Country: String + CustomerId: Int! + Email: String! + "An object relationship" + Employee: Employee + Fax: String + FirstName: String! + "An array relationship" + Invoices("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "An aggregate relationship" + Invoices_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + LastName: String! + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregated selection of \"Customer\"" +type Customer_aggregate { + aggregate: Customer_aggregate_fields + nodes: [Customer!]! +} + +input Customer_aggregate_bool_exp { + count: Customer_aggregate_bool_exp_count +} + +input Customer_aggregate_bool_exp_count { + arguments: [Customer_select_column!] + distinct: Boolean + filter: Customer_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Customer\"" +type Customer_aggregate_fields { + avg: Customer_avg_fields + count(columns: [Customer_select_column!], distinct: Boolean): Int! + max: Customer_max_fields + min: Customer_min_fields + stddev: Customer_stddev_fields + stddev_pop: Customer_stddev_pop_fields + stddev_samp: Customer_stddev_samp_fields + sum: Customer_sum_fields + var_pop: Customer_var_pop_fields + var_samp: Customer_var_samp_fields + variance: Customer_variance_fields +} + +"order by aggregate values of table \"Customer\"" +input Customer_aggregate_order_by { + avg: Customer_avg_order_by + count: order_by + max: Customer_max_order_by + min: Customer_min_order_by + stddev: Customer_stddev_order_by + stddev_pop: Customer_stddev_pop_order_by + stddev_samp: Customer_stddev_samp_order_by + sum: Customer_sum_order_by + var_pop: Customer_var_pop_order_by + var_samp: Customer_var_samp_order_by + variance: Customer_variance_order_by +} + +"input type for inserting array relation for remote table \"Customer\"" +input Customer_arr_rel_insert_input { + data: [Customer_insert_input!]! + "upsert condition" on_conflict: Customer_on_conflict +} + +"aggregate avg on columns" +type Customer_avg_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by avg() on columns of table \"Customer\"" +input Customer_avg_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"Boolean expression to filter rows from the table \"Customer\". All fields are combined with a logical 'AND'." +input Customer_bool_exp { + Address: String_comparison_exp + City: String_comparison_exp + Company: String_comparison_exp + Country: String_comparison_exp + CustomerId: Int_comparison_exp + Email: String_comparison_exp + Employee: Employee_bool_exp + Fax: String_comparison_exp + FirstName: String_comparison_exp + Invoices: Invoice_bool_exp + Invoices_aggregate: Invoice_aggregate_bool_exp + LastName: String_comparison_exp + Phone: String_comparison_exp + PostalCode: String_comparison_exp + State: String_comparison_exp + SupportRepId: Int_comparison_exp + _and: [Customer_bool_exp!] + _not: Customer_bool_exp + _or: [Customer_bool_exp!] +} + +"unique or primary key constraints on table \"Customer\"" +enum Customer_constraint { + "unique or primary key constraint on columns \"CustomerId\"" PK_Customer +} + +"input type for incrementing numeric columns in table \"Customer\"" +input Customer_inc_input { + SupportRepId: Int +} + +"input type for inserting data into table \"Customer\"" +input Customer_insert_input { + Address: String + City: String + Company: String + Country: String + Email: String + Employee: Employee_obj_rel_insert_input + Fax: String + FirstName: String + Invoices: Invoice_arr_rel_insert_input + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate max on columns" +type Customer_max_fields { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"order by max() on columns of table \"Customer\"" +input Customer_max_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Fax: order_by + FirstName: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"aggregate min on columns" +type Customer_min_fields { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"order by min() on columns of table \"Customer\"" +input Customer_min_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Fax: order_by + FirstName: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"response of any mutation on the table \"Customer\"" +type Customer_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Customer!]! +} + +"input type for inserting object relation for remote table \"Customer\"" +input Customer_obj_rel_insert_input { + data: Customer_insert_input! + "upsert condition" on_conflict: Customer_on_conflict +} + +"on_conflict condition type for table \"Customer\"" +input Customer_on_conflict { + constraint: Customer_constraint! + update_columns: [Customer_update_column!]! = [] + where: Customer_bool_exp +} + +"Ordering options when selecting data from \"Customer\"." +input Customer_order_by { + Address: order_by + City: order_by + Company: order_by + Country: order_by + CustomerId: order_by + Email: order_by + Employee: Employee_order_by + Fax: order_by + FirstName: order_by + Invoices_aggregate: Invoice_aggregate_order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + State: order_by + SupportRepId: order_by +} + +"primary key columns input for table: Customer" +input Customer_pk_columns_input { + CustomerId: Int! +} + +"select columns of table \"Customer\"" +enum Customer_select_column { + "column name" Address + "column name" City + "column name" Company + "column name" Country + "column name" CustomerId + "column name" Email + "column name" Fax + "column name" FirstName + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" State + "column name" SupportRepId +} + +"input type for updating data in table \"Customer\"" +input Customer_set_input { + Address: String + City: String + Company: String + Country: String + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate stddev on columns" +type Customer_stddev_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev() on columns of table \"Customer\"" +input Customer_stddev_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate stddev_pop on columns" +type Customer_stddev_pop_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev_pop() on columns of table \"Customer\"" +input Customer_stddev_pop_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate stddev_samp on columns" +type Customer_stddev_samp_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by stddev_samp() on columns of table \"Customer\"" +input Customer_stddev_samp_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"Streaming cursor of the table \"Customer\"" +input Customer_stream_cursor_input { + "Stream column input with initial value" initial_value: Customer_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Customer_stream_cursor_value_input { + Address: String + City: String + Company: String + Country: String + CustomerId: Int + Email: String + Fax: String + FirstName: String + LastName: String + Phone: String + PostalCode: String + State: String + SupportRepId: Int +} + +"aggregate sum on columns" +type Customer_sum_fields { + CustomerId: Int + SupportRepId: Int +} + +"order by sum() on columns of table \"Customer\"" +input Customer_sum_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"update columns of table \"Customer\"" +enum Customer_update_column { + "column name" Address + "column name" City + "column name" Company + "column name" Country + "column name" Email + "column name" Fax + "column name" FirstName + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" State + "column name" SupportRepId +} + +input Customer_updates { + "increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input + "sets the columns of the filtered rows to the given values" _set: Customer_set_input + "filter the rows which have to be updated" where: Customer_bool_exp! +} + +"aggregate var_pop on columns" +type Customer_var_pop_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by var_pop() on columns of table \"Customer\"" +input Customer_var_pop_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate var_samp on columns" +type Customer_var_samp_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by var_samp() on columns of table \"Customer\"" +input Customer_var_samp_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"aggregate variance on columns" +type Customer_variance_fields { + CustomerId: Float + SupportRepId: Float +} + +"order by variance() on columns of table \"Customer\"" +input Customer_variance_order_by { + CustomerId: order_by + SupportRepId: order_by +} + +"columns and relationships of \"Employee\"" +type Employee { + Address: String + BirthDate: timestamp + City: String + Country: String + "An array relationship" + Customers("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "An aggregate relationship" + Customers_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + Email: String + "An object relationship" + Employee: Employee + EmployeeId: Int! + "An array relationship" + Employees("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "An aggregate relationship" + Employees_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + Fax: String + FirstName: String! + HireDate: timestamp + LastName: String! + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregated selection of \"Employee\"" +type Employee_aggregate { + aggregate: Employee_aggregate_fields + nodes: [Employee!]! +} + +input Employee_aggregate_bool_exp { + count: Employee_aggregate_bool_exp_count +} + +input Employee_aggregate_bool_exp_count { + arguments: [Employee_select_column!] + distinct: Boolean + filter: Employee_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Employee\"" +type Employee_aggregate_fields { + avg: Employee_avg_fields + count(columns: [Employee_select_column!], distinct: Boolean): Int! + max: Employee_max_fields + min: Employee_min_fields + stddev: Employee_stddev_fields + stddev_pop: Employee_stddev_pop_fields + stddev_samp: Employee_stddev_samp_fields + sum: Employee_sum_fields + var_pop: Employee_var_pop_fields + var_samp: Employee_var_samp_fields + variance: Employee_variance_fields +} + +"order by aggregate values of table \"Employee\"" +input Employee_aggregate_order_by { + avg: Employee_avg_order_by + count: order_by + max: Employee_max_order_by + min: Employee_min_order_by + stddev: Employee_stddev_order_by + stddev_pop: Employee_stddev_pop_order_by + stddev_samp: Employee_stddev_samp_order_by + sum: Employee_sum_order_by + var_pop: Employee_var_pop_order_by + var_samp: Employee_var_samp_order_by + variance: Employee_variance_order_by +} + +"input type for inserting array relation for remote table \"Employee\"" +input Employee_arr_rel_insert_input { + data: [Employee_insert_input!]! + "upsert condition" on_conflict: Employee_on_conflict +} + +"aggregate avg on columns" +type Employee_avg_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by avg() on columns of table \"Employee\"" +input Employee_avg_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"Boolean expression to filter rows from the table \"Employee\". All fields are combined with a logical 'AND'." +input Employee_bool_exp { + Address: String_comparison_exp + BirthDate: timestamp_comparison_exp + City: String_comparison_exp + Country: String_comparison_exp + Customers: Customer_bool_exp + Customers_aggregate: Customer_aggregate_bool_exp + Email: String_comparison_exp + Employee: Employee_bool_exp + EmployeeId: Int_comparison_exp + Employees: Employee_bool_exp + Employees_aggregate: Employee_aggregate_bool_exp + Fax: String_comparison_exp + FirstName: String_comparison_exp + HireDate: timestamp_comparison_exp + LastName: String_comparison_exp + Phone: String_comparison_exp + PostalCode: String_comparison_exp + ReportsTo: Int_comparison_exp + State: String_comparison_exp + Title: String_comparison_exp + _and: [Employee_bool_exp!] + _not: Employee_bool_exp + _or: [Employee_bool_exp!] +} + +"unique or primary key constraints on table \"Employee\"" +enum Employee_constraint { + "unique or primary key constraint on columns \"EmployeeId\"" PK_Employee +} + +"input type for incrementing numeric columns in table \"Employee\"" +input Employee_inc_input { + ReportsTo: Int +} + +"input type for inserting data into table \"Employee\"" +input Employee_insert_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Customers: Customer_arr_rel_insert_input + Email: String + Employee: Employee_obj_rel_insert_input + Employees: Employee_arr_rel_insert_input + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate max on columns" +type Employee_max_fields { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"order by max() on columns of table \"Employee\"" +input Employee_max_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Email: order_by + EmployeeId: order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"aggregate min on columns" +type Employee_min_fields { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"order by min() on columns of table \"Employee\"" +input Employee_min_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Email: order_by + EmployeeId: order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"response of any mutation on the table \"Employee\"" +type Employee_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Employee!]! +} + +"input type for inserting object relation for remote table \"Employee\"" +input Employee_obj_rel_insert_input { + data: Employee_insert_input! + "upsert condition" on_conflict: Employee_on_conflict +} + +"on_conflict condition type for table \"Employee\"" +input Employee_on_conflict { + constraint: Employee_constraint! + update_columns: [Employee_update_column!]! = [] + where: Employee_bool_exp +} + +"Ordering options when selecting data from \"Employee\"." +input Employee_order_by { + Address: order_by + BirthDate: order_by + City: order_by + Country: order_by + Customers_aggregate: Customer_aggregate_order_by + Email: order_by + Employee: Employee_order_by + EmployeeId: order_by + Employees_aggregate: Employee_aggregate_order_by + Fax: order_by + FirstName: order_by + HireDate: order_by + LastName: order_by + Phone: order_by + PostalCode: order_by + ReportsTo: order_by + State: order_by + Title: order_by +} + +"primary key columns input for table: Employee" +input Employee_pk_columns_input { + EmployeeId: Int! +} + +"select columns of table \"Employee\"" +enum Employee_select_column { + "column name" Address + "column name" BirthDate + "column name" City + "column name" Country + "column name" Email + "column name" EmployeeId + "column name" Fax + "column name" FirstName + "column name" HireDate + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" ReportsTo + "column name" State + "column name" Title +} + +"input type for updating data in table \"Employee\"" +input Employee_set_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate stddev on columns" +type Employee_stddev_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev() on columns of table \"Employee\"" +input Employee_stddev_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate stddev_pop on columns" +type Employee_stddev_pop_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev_pop() on columns of table \"Employee\"" +input Employee_stddev_pop_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate stddev_samp on columns" +type Employee_stddev_samp_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by stddev_samp() on columns of table \"Employee\"" +input Employee_stddev_samp_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"Streaming cursor of the table \"Employee\"" +input Employee_stream_cursor_input { + "Stream column input with initial value" initial_value: Employee_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Employee_stream_cursor_value_input { + Address: String + BirthDate: timestamp + City: String + Country: String + Email: String + EmployeeId: Int + Fax: String + FirstName: String + HireDate: timestamp + LastName: String + Phone: String + PostalCode: String + ReportsTo: Int + State: String + Title: String +} + +"aggregate sum on columns" +type Employee_sum_fields { + EmployeeId: Int + ReportsTo: Int +} + +"order by sum() on columns of table \"Employee\"" +input Employee_sum_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"update columns of table \"Employee\"" +enum Employee_update_column { + "column name" Address + "column name" BirthDate + "column name" City + "column name" Country + "column name" Email + "column name" Fax + "column name" FirstName + "column name" HireDate + "column name" LastName + "column name" Phone + "column name" PostalCode + "column name" ReportsTo + "column name" State + "column name" Title +} + +input Employee_updates { + "increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input + "sets the columns of the filtered rows to the given values" _set: Employee_set_input + "filter the rows which have to be updated" where: Employee_bool_exp! +} + +"aggregate var_pop on columns" +type Employee_var_pop_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by var_pop() on columns of table \"Employee\"" +input Employee_var_pop_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate var_samp on columns" +type Employee_var_samp_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by var_samp() on columns of table \"Employee\"" +input Employee_var_samp_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +"aggregate variance on columns" +type Employee_variance_fields { + EmployeeId: Float + ReportsTo: Float +} + +"order by variance() on columns of table \"Employee\"" +input Employee_variance_order_by { + EmployeeId: order_by + ReportsTo: order_by +} + +scalar Float + +"columns and relationships of \"Genre\"" +type Genre { + GenreId: Int! + Name: String + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"Genre\"" +type Genre_aggregate { + aggregate: Genre_aggregate_fields + nodes: [Genre!]! +} + +"aggregate fields of \"Genre\"" +type Genre_aggregate_fields { + avg: Genre_avg_fields + count(columns: [Genre_select_column!], distinct: Boolean): Int! + max: Genre_max_fields + min: Genre_min_fields + stddev: Genre_stddev_fields + stddev_pop: Genre_stddev_pop_fields + stddev_samp: Genre_stddev_samp_fields + sum: Genre_sum_fields + var_pop: Genre_var_pop_fields + var_samp: Genre_var_samp_fields + variance: Genre_variance_fields +} + +"aggregate avg on columns" +type Genre_avg_fields { + GenreId: Float +} + +"Boolean expression to filter rows from the table \"Genre\". All fields are combined with a logical 'AND'." +input Genre_bool_exp { + GenreId: Int_comparison_exp + Name: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [Genre_bool_exp!] + _not: Genre_bool_exp + _or: [Genre_bool_exp!] +} + +"unique or primary key constraints on table \"Genre\"" +enum Genre_constraint { + "unique or primary key constraint on columns \"GenreId\"" PK_Genre +} + +"input type for inserting data into table \"Genre\"" +input Genre_insert_input { + Name: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type Genre_max_fields { + GenreId: Int + Name: String +} + +"aggregate min on columns" +type Genre_min_fields { + GenreId: Int + Name: String +} + +"response of any mutation on the table \"Genre\"" +type Genre_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Genre!]! +} + +"input type for inserting object relation for remote table \"Genre\"" +input Genre_obj_rel_insert_input { + data: Genre_insert_input! + "upsert condition" on_conflict: Genre_on_conflict +} + +"on_conflict condition type for table \"Genre\"" +input Genre_on_conflict { + constraint: Genre_constraint! + update_columns: [Genre_update_column!]! = [] + where: Genre_bool_exp +} + +"Ordering options when selecting data from \"Genre\"." +input Genre_order_by { + GenreId: order_by + Name: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: Genre" +input Genre_pk_columns_input { + GenreId: Int! +} + +"select columns of table \"Genre\"" +enum Genre_select_column { + "column name" GenreId + "column name" Name +} + +"input type for updating data in table \"Genre\"" +input Genre_set_input { + Name: String +} + +"aggregate stddev on columns" +type Genre_stddev_fields { + GenreId: Float +} + +"aggregate stddev_pop on columns" +type Genre_stddev_pop_fields { + GenreId: Float +} + +"aggregate stddev_samp on columns" +type Genre_stddev_samp_fields { + GenreId: Float +} + +"Streaming cursor of the table \"Genre\"" +input Genre_stream_cursor_input { + "Stream column input with initial value" initial_value: Genre_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Genre_stream_cursor_value_input { + GenreId: Int + Name: String +} + +"aggregate sum on columns" +type Genre_sum_fields { + GenreId: Int +} + +"update columns of table \"Genre\"" +enum Genre_update_column { + "column name" Name +} + +input Genre_updates { + "sets the columns of the filtered rows to the given values" _set: Genre_set_input + "filter the rows which have to be updated" where: Genre_bool_exp! +} + +"aggregate var_pop on columns" +type Genre_var_pop_fields { + GenreId: Float +} + +"aggregate var_samp on columns" +type Genre_var_samp_fields { + GenreId: Float +} + +"aggregate variance on columns" +type Genre_variance_fields { + GenreId: Float +} + +scalar Int + +"Boolean expression to compare columns of type \"Int\". All fields are combined with logical 'AND'." +input Int_comparison_exp { + _eq: Int + _gt: Int + _gte: Int + _in: [Int!] + _is_null: Boolean + _lt: Int + _lte: Int + _neq: Int + _nin: [Int!] +} + +"columns and relationships of \"Invoice\"" +type Invoice { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + "An object relationship" + Customer: Customer! + CustomerId: Int! + InvoiceDate: timestamp! + InvoiceId: Int! + "An array relationship" + InvoiceLines("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "An aggregate relationship" + InvoiceLines_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + Total: numeric! +} + +"columns and relationships of \"InvoiceLine\"" +type InvoiceLine { + "An object relationship" + Invoice: Invoice! + InvoiceId: Int! + InvoiceLineId: Int! + Quantity: Int! + "An object relationship" + Track: Track! + TrackId: Int! + UnitPrice: numeric! +} + +"aggregated selection of \"InvoiceLine\"" +type InvoiceLine_aggregate { + aggregate: InvoiceLine_aggregate_fields + nodes: [InvoiceLine!]! +} + +input InvoiceLine_aggregate_bool_exp { + count: InvoiceLine_aggregate_bool_exp_count +} + +input InvoiceLine_aggregate_bool_exp_count { + arguments: [InvoiceLine_select_column!] + distinct: Boolean + filter: InvoiceLine_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"InvoiceLine\"" +type InvoiceLine_aggregate_fields { + avg: InvoiceLine_avg_fields + count(columns: [InvoiceLine_select_column!], distinct: Boolean): Int! + max: InvoiceLine_max_fields + min: InvoiceLine_min_fields + stddev: InvoiceLine_stddev_fields + stddev_pop: InvoiceLine_stddev_pop_fields + stddev_samp: InvoiceLine_stddev_samp_fields + sum: InvoiceLine_sum_fields + var_pop: InvoiceLine_var_pop_fields + var_samp: InvoiceLine_var_samp_fields + variance: InvoiceLine_variance_fields +} + +"order by aggregate values of table \"InvoiceLine\"" +input InvoiceLine_aggregate_order_by { + avg: InvoiceLine_avg_order_by + count: order_by + max: InvoiceLine_max_order_by + min: InvoiceLine_min_order_by + stddev: InvoiceLine_stddev_order_by + stddev_pop: InvoiceLine_stddev_pop_order_by + stddev_samp: InvoiceLine_stddev_samp_order_by + sum: InvoiceLine_sum_order_by + var_pop: InvoiceLine_var_pop_order_by + var_samp: InvoiceLine_var_samp_order_by + variance: InvoiceLine_variance_order_by +} + +"input type for inserting array relation for remote table \"InvoiceLine\"" +input InvoiceLine_arr_rel_insert_input { + data: [InvoiceLine_insert_input!]! + "upsert condition" on_conflict: InvoiceLine_on_conflict +} + +"aggregate avg on columns" +type InvoiceLine_avg_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by avg() on columns of table \"InvoiceLine\"" +input InvoiceLine_avg_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Boolean expression to filter rows from the table \"InvoiceLine\". All fields are combined with a logical 'AND'." +input InvoiceLine_bool_exp { + Invoice: Invoice_bool_exp + InvoiceId: Int_comparison_exp + InvoiceLineId: Int_comparison_exp + Quantity: Int_comparison_exp + Track: Track_bool_exp + TrackId: Int_comparison_exp + UnitPrice: numeric_comparison_exp + _and: [InvoiceLine_bool_exp!] + _not: InvoiceLine_bool_exp + _or: [InvoiceLine_bool_exp!] +} + +"unique or primary key constraints on table \"InvoiceLine\"" +enum InvoiceLine_constraint { + "unique or primary key constraint on columns \"InvoiceLineId\"" PK_InvoiceLine +} + +"input type for incrementing numeric columns in table \"InvoiceLine\"" +input InvoiceLine_inc_input { + InvoiceId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"input type for inserting data into table \"InvoiceLine\"" +input InvoiceLine_insert_input { + Invoice: Invoice_obj_rel_insert_input + InvoiceId: Int + Quantity: Int + Track: Track_obj_rel_insert_input + TrackId: Int + UnitPrice: numeric +} + +"aggregate max on columns" +type InvoiceLine_max_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by max() on columns of table \"InvoiceLine\"" +input InvoiceLine_max_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate min on columns" +type InvoiceLine_min_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by min() on columns of table \"InvoiceLine\"" +input InvoiceLine_min_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"response of any mutation on the table \"InvoiceLine\"" +type InvoiceLine_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [InvoiceLine!]! +} + +"on_conflict condition type for table \"InvoiceLine\"" +input InvoiceLine_on_conflict { + constraint: InvoiceLine_constraint! + update_columns: [InvoiceLine_update_column!]! = [] + where: InvoiceLine_bool_exp +} + +"Ordering options when selecting data from \"InvoiceLine\"." +input InvoiceLine_order_by { + Invoice: Invoice_order_by + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + Track: Track_order_by + TrackId: order_by + UnitPrice: order_by +} + +"primary key columns input for table: InvoiceLine" +input InvoiceLine_pk_columns_input { + InvoiceLineId: Int! +} + +"select columns of table \"InvoiceLine\"" +enum InvoiceLine_select_column { + "column name" InvoiceId + "column name" InvoiceLineId + "column name" Quantity + "column name" TrackId + "column name" UnitPrice +} + +"input type for updating data in table \"InvoiceLine\"" +input InvoiceLine_set_input { + InvoiceId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"aggregate stddev on columns" +type InvoiceLine_stddev_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_pop on columns" +type InvoiceLine_stddev_pop_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_pop() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_pop_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_samp on columns" +type InvoiceLine_stddev_samp_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_samp() on columns of table \"InvoiceLine\"" +input InvoiceLine_stddev_samp_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Streaming cursor of the table \"InvoiceLine\"" +input InvoiceLine_stream_cursor_input { + "Stream column input with initial value" initial_value: InvoiceLine_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input InvoiceLine_stream_cursor_value_input { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"aggregate sum on columns" +type InvoiceLine_sum_fields { + InvoiceId: Int + InvoiceLineId: Int + Quantity: Int + TrackId: Int + UnitPrice: numeric +} + +"order by sum() on columns of table \"InvoiceLine\"" +input InvoiceLine_sum_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"update columns of table \"InvoiceLine\"" +enum InvoiceLine_update_column { + "column name" InvoiceId + "column name" Quantity + "column name" TrackId + "column name" UnitPrice +} + +input InvoiceLine_updates { + "increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input + "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input + "filter the rows which have to be updated" where: InvoiceLine_bool_exp! +} + +"aggregate var_pop on columns" +type InvoiceLine_var_pop_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_pop() on columns of table \"InvoiceLine\"" +input InvoiceLine_var_pop_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate var_samp on columns" +type InvoiceLine_var_samp_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_samp() on columns of table \"InvoiceLine\"" +input InvoiceLine_var_samp_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate variance on columns" +type InvoiceLine_variance_fields { + InvoiceId: Float + InvoiceLineId: Float + Quantity: Float + TrackId: Float + UnitPrice: Float +} + +"order by variance() on columns of table \"InvoiceLine\"" +input InvoiceLine_variance_order_by { + InvoiceId: order_by + InvoiceLineId: order_by + Quantity: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregated selection of \"Invoice\"" +type Invoice_aggregate { + aggregate: Invoice_aggregate_fields + nodes: [Invoice!]! +} + +input Invoice_aggregate_bool_exp { + count: Invoice_aggregate_bool_exp_count +} + +input Invoice_aggregate_bool_exp_count { + arguments: [Invoice_select_column!] + distinct: Boolean + filter: Invoice_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Invoice\"" +type Invoice_aggregate_fields { + avg: Invoice_avg_fields + count(columns: [Invoice_select_column!], distinct: Boolean): Int! + max: Invoice_max_fields + min: Invoice_min_fields + stddev: Invoice_stddev_fields + stddev_pop: Invoice_stddev_pop_fields + stddev_samp: Invoice_stddev_samp_fields + sum: Invoice_sum_fields + var_pop: Invoice_var_pop_fields + var_samp: Invoice_var_samp_fields + variance: Invoice_variance_fields +} + +"order by aggregate values of table \"Invoice\"" +input Invoice_aggregate_order_by { + avg: Invoice_avg_order_by + count: order_by + max: Invoice_max_order_by + min: Invoice_min_order_by + stddev: Invoice_stddev_order_by + stddev_pop: Invoice_stddev_pop_order_by + stddev_samp: Invoice_stddev_samp_order_by + sum: Invoice_sum_order_by + var_pop: Invoice_var_pop_order_by + var_samp: Invoice_var_samp_order_by + variance: Invoice_variance_order_by +} + +"input type for inserting array relation for remote table \"Invoice\"" +input Invoice_arr_rel_insert_input { + data: [Invoice_insert_input!]! + "upsert condition" on_conflict: Invoice_on_conflict +} + +"aggregate avg on columns" +type Invoice_avg_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by avg() on columns of table \"Invoice\"" +input Invoice_avg_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"Boolean expression to filter rows from the table \"Invoice\". All fields are combined with a logical 'AND'." +input Invoice_bool_exp { + BillingAddress: String_comparison_exp + BillingCity: String_comparison_exp + BillingCountry: String_comparison_exp + BillingPostalCode: String_comparison_exp + BillingState: String_comparison_exp + Customer: Customer_bool_exp + CustomerId: Int_comparison_exp + InvoiceDate: timestamp_comparison_exp + InvoiceId: Int_comparison_exp + InvoiceLines: InvoiceLine_bool_exp + InvoiceLines_aggregate: InvoiceLine_aggregate_bool_exp + Total: numeric_comparison_exp + _and: [Invoice_bool_exp!] + _not: Invoice_bool_exp + _or: [Invoice_bool_exp!] +} + +"unique or primary key constraints on table \"Invoice\"" +enum Invoice_constraint { + "unique or primary key constraint on columns \"InvoiceId\"" PK_Invoice +} + +"input type for incrementing numeric columns in table \"Invoice\"" +input Invoice_inc_input { + CustomerId: Int + Total: numeric +} + +"input type for inserting data into table \"Invoice\"" +input Invoice_insert_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + Customer: Customer_obj_rel_insert_input + CustomerId: Int + InvoiceDate: timestamp + InvoiceLines: InvoiceLine_arr_rel_insert_input + Total: numeric +} + +"aggregate max on columns" +type Invoice_max_fields { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"order by max() on columns of table \"Invoice\"" +input Invoice_max_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate min on columns" +type Invoice_min_fields { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"order by min() on columns of table \"Invoice\"" +input Invoice_min_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + Total: order_by +} + +"response of any mutation on the table \"Invoice\"" +type Invoice_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Invoice!]! +} + +"input type for inserting object relation for remote table \"Invoice\"" +input Invoice_obj_rel_insert_input { + data: Invoice_insert_input! + "upsert condition" on_conflict: Invoice_on_conflict +} + +"on_conflict condition type for table \"Invoice\"" +input Invoice_on_conflict { + constraint: Invoice_constraint! + update_columns: [Invoice_update_column!]! = [] + where: Invoice_bool_exp +} + +"Ordering options when selecting data from \"Invoice\"." +input Invoice_order_by { + BillingAddress: order_by + BillingCity: order_by + BillingCountry: order_by + BillingPostalCode: order_by + BillingState: order_by + Customer: Customer_order_by + CustomerId: order_by + InvoiceDate: order_by + InvoiceId: order_by + InvoiceLines_aggregate: InvoiceLine_aggregate_order_by + Total: order_by +} + +"primary key columns input for table: Invoice" +input Invoice_pk_columns_input { + InvoiceId: Int! +} + +"select columns of table \"Invoice\"" +enum Invoice_select_column { + "column name" BillingAddress + "column name" BillingCity + "column name" BillingCountry + "column name" BillingPostalCode + "column name" BillingState + "column name" CustomerId + "column name" InvoiceDate + "column name" InvoiceId + "column name" Total +} + +"input type for updating data in table \"Invoice\"" +input Invoice_set_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + Total: numeric +} + +"aggregate stddev on columns" +type Invoice_stddev_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev() on columns of table \"Invoice\"" +input Invoice_stddev_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate stddev_pop on columns" +type Invoice_stddev_pop_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev_pop() on columns of table \"Invoice\"" +input Invoice_stddev_pop_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate stddev_samp on columns" +type Invoice_stddev_samp_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by stddev_samp() on columns of table \"Invoice\"" +input Invoice_stddev_samp_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"Streaming cursor of the table \"Invoice\"" +input Invoice_stream_cursor_input { + "Stream column input with initial value" initial_value: Invoice_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Invoice_stream_cursor_value_input { + BillingAddress: String + BillingCity: String + BillingCountry: String + BillingPostalCode: String + BillingState: String + CustomerId: Int + InvoiceDate: timestamp + InvoiceId: Int + Total: numeric +} + +"aggregate sum on columns" +type Invoice_sum_fields { + CustomerId: Int + InvoiceId: Int + Total: numeric +} + +"order by sum() on columns of table \"Invoice\"" +input Invoice_sum_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"update columns of table \"Invoice\"" +enum Invoice_update_column { + "column name" BillingAddress + "column name" BillingCity + "column name" BillingCountry + "column name" BillingPostalCode + "column name" BillingState + "column name" CustomerId + "column name" InvoiceDate + "column name" Total +} + +input Invoice_updates { + "increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input + "sets the columns of the filtered rows to the given values" _set: Invoice_set_input + "filter the rows which have to be updated" where: Invoice_bool_exp! +} + +"aggregate var_pop on columns" +type Invoice_var_pop_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by var_pop() on columns of table \"Invoice\"" +input Invoice_var_pop_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate var_samp on columns" +type Invoice_var_samp_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by var_samp() on columns of table \"Invoice\"" +input Invoice_var_samp_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"aggregate variance on columns" +type Invoice_variance_fields { + CustomerId: Float + InvoiceId: Float + Total: Float +} + +"order by variance() on columns of table \"Invoice\"" +input Invoice_variance_order_by { + CustomerId: order_by + InvoiceId: order_by + Total: order_by +} + +"columns and relationships of \"MediaType\"" +type MediaType { + MediaTypeId: Int! + Name: String + "An array relationship" + Tracks("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "An aggregate relationship" + Tracks_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! +} + +"aggregated selection of \"MediaType\"" +type MediaType_aggregate { + aggregate: MediaType_aggregate_fields + nodes: [MediaType!]! +} + +"aggregate fields of \"MediaType\"" +type MediaType_aggregate_fields { + avg: MediaType_avg_fields + count(columns: [MediaType_select_column!], distinct: Boolean): Int! + max: MediaType_max_fields + min: MediaType_min_fields + stddev: MediaType_stddev_fields + stddev_pop: MediaType_stddev_pop_fields + stddev_samp: MediaType_stddev_samp_fields + sum: MediaType_sum_fields + var_pop: MediaType_var_pop_fields + var_samp: MediaType_var_samp_fields + variance: MediaType_variance_fields +} + +"aggregate avg on columns" +type MediaType_avg_fields { + MediaTypeId: Float +} + +"Boolean expression to filter rows from the table \"MediaType\". All fields are combined with a logical 'AND'." +input MediaType_bool_exp { + MediaTypeId: Int_comparison_exp + Name: String_comparison_exp + Tracks: Track_bool_exp + Tracks_aggregate: Track_aggregate_bool_exp + _and: [MediaType_bool_exp!] + _not: MediaType_bool_exp + _or: [MediaType_bool_exp!] +} + +"unique or primary key constraints on table \"MediaType\"" +enum MediaType_constraint { + "unique or primary key constraint on columns \"MediaTypeId\"" PK_MediaType +} + +"input type for inserting data into table \"MediaType\"" +input MediaType_insert_input { + Name: String + Tracks: Track_arr_rel_insert_input +} + +"aggregate max on columns" +type MediaType_max_fields { + MediaTypeId: Int + Name: String +} + +"aggregate min on columns" +type MediaType_min_fields { + MediaTypeId: Int + Name: String +} + +"response of any mutation on the table \"MediaType\"" +type MediaType_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [MediaType!]! +} + +"input type for inserting object relation for remote table \"MediaType\"" +input MediaType_obj_rel_insert_input { + data: MediaType_insert_input! + "upsert condition" on_conflict: MediaType_on_conflict +} + +"on_conflict condition type for table \"MediaType\"" +input MediaType_on_conflict { + constraint: MediaType_constraint! + update_columns: [MediaType_update_column!]! = [] + where: MediaType_bool_exp +} + +"Ordering options when selecting data from \"MediaType\"." +input MediaType_order_by { + MediaTypeId: order_by + Name: order_by + Tracks_aggregate: Track_aggregate_order_by +} + +"primary key columns input for table: MediaType" +input MediaType_pk_columns_input { + MediaTypeId: Int! +} + +"select columns of table \"MediaType\"" +enum MediaType_select_column { + "column name" MediaTypeId + "column name" Name +} + +"input type for updating data in table \"MediaType\"" +input MediaType_set_input { + Name: String +} + +"aggregate stddev on columns" +type MediaType_stddev_fields { + MediaTypeId: Float +} + +"aggregate stddev_pop on columns" +type MediaType_stddev_pop_fields { + MediaTypeId: Float +} + +"aggregate stddev_samp on columns" +type MediaType_stddev_samp_fields { + MediaTypeId: Float +} + +"Streaming cursor of the table \"MediaType\"" +input MediaType_stream_cursor_input { + "Stream column input with initial value" initial_value: MediaType_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input MediaType_stream_cursor_value_input { + MediaTypeId: Int + Name: String +} + +"aggregate sum on columns" +type MediaType_sum_fields { + MediaTypeId: Int +} + +"update columns of table \"MediaType\"" +enum MediaType_update_column { + "column name" Name +} + +input MediaType_updates { + "sets the columns of the filtered rows to the given values" _set: MediaType_set_input + "filter the rows which have to be updated" where: MediaType_bool_exp! +} + +"aggregate var_pop on columns" +type MediaType_var_pop_fields { + MediaTypeId: Float +} + +"aggregate var_samp on columns" +type MediaType_var_samp_fields { + MediaTypeId: Float +} + +"aggregate variance on columns" +type MediaType_variance_fields { + MediaTypeId: Float +} + +"columns and relationships of \"Playlist\"" +type Playlist { + Name: String + PlaylistId: Int! + "An array relationship" + PlaylistTracks("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "An aggregate relationship" + PlaylistTracks_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! +} + +"columns and relationships of \"PlaylistTrack\"" +type PlaylistTrack { + "An object relationship" + Playlist: Playlist! + PlaylistId: Int! + "An object relationship" + Track: Track! + TrackId: Int! +} + +"aggregated selection of \"PlaylistTrack\"" +type PlaylistTrack_aggregate { + aggregate: PlaylistTrack_aggregate_fields + nodes: [PlaylistTrack!]! +} + +input PlaylistTrack_aggregate_bool_exp { + count: PlaylistTrack_aggregate_bool_exp_count +} + +input PlaylistTrack_aggregate_bool_exp_count { + arguments: [PlaylistTrack_select_column!] + distinct: Boolean + filter: PlaylistTrack_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"PlaylistTrack\"" +type PlaylistTrack_aggregate_fields { + avg: PlaylistTrack_avg_fields + count(columns: [PlaylistTrack_select_column!], distinct: Boolean): Int! + max: PlaylistTrack_max_fields + min: PlaylistTrack_min_fields + stddev: PlaylistTrack_stddev_fields + stddev_pop: PlaylistTrack_stddev_pop_fields + stddev_samp: PlaylistTrack_stddev_samp_fields + sum: PlaylistTrack_sum_fields + var_pop: PlaylistTrack_var_pop_fields + var_samp: PlaylistTrack_var_samp_fields + variance: PlaylistTrack_variance_fields +} + +"order by aggregate values of table \"PlaylistTrack\"" +input PlaylistTrack_aggregate_order_by { + avg: PlaylistTrack_avg_order_by + count: order_by + max: PlaylistTrack_max_order_by + min: PlaylistTrack_min_order_by + stddev: PlaylistTrack_stddev_order_by + stddev_pop: PlaylistTrack_stddev_pop_order_by + stddev_samp: PlaylistTrack_stddev_samp_order_by + sum: PlaylistTrack_sum_order_by + var_pop: PlaylistTrack_var_pop_order_by + var_samp: PlaylistTrack_var_samp_order_by + variance: PlaylistTrack_variance_order_by +} + +"input type for inserting array relation for remote table \"PlaylistTrack\"" +input PlaylistTrack_arr_rel_insert_input { + data: [PlaylistTrack_insert_input!]! + "upsert condition" on_conflict: PlaylistTrack_on_conflict +} + +"aggregate avg on columns" +type PlaylistTrack_avg_fields { + PlaylistId: Float + TrackId: Float +} + +"order by avg() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_avg_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"Boolean expression to filter rows from the table \"PlaylistTrack\". All fields are combined with a logical 'AND'." +input PlaylistTrack_bool_exp { + Playlist: Playlist_bool_exp + PlaylistId: Int_comparison_exp + Track: Track_bool_exp + TrackId: Int_comparison_exp + _and: [PlaylistTrack_bool_exp!] + _not: PlaylistTrack_bool_exp + _or: [PlaylistTrack_bool_exp!] +} + +"unique or primary key constraints on table \"PlaylistTrack\"" +enum PlaylistTrack_constraint { + "unique or primary key constraint on columns \"TrackId\", \"PlaylistId\"" PK_PlaylistTrack +} + +"input type for incrementing numeric columns in table \"PlaylistTrack\"" +input PlaylistTrack_inc_input { + PlaylistId: Int + TrackId: Int +} + +"input type for inserting data into table \"PlaylistTrack\"" +input PlaylistTrack_insert_input { + Playlist: Playlist_obj_rel_insert_input + PlaylistId: Int + Track: Track_obj_rel_insert_input + TrackId: Int +} + +"aggregate max on columns" +type PlaylistTrack_max_fields { + PlaylistId: Int + TrackId: Int +} + +"order by max() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_max_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate min on columns" +type PlaylistTrack_min_fields { + PlaylistId: Int + TrackId: Int +} + +"order by min() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_min_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"response of any mutation on the table \"PlaylistTrack\"" +type PlaylistTrack_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [PlaylistTrack!]! +} + +"on_conflict condition type for table \"PlaylistTrack\"" +input PlaylistTrack_on_conflict { + constraint: PlaylistTrack_constraint! + update_columns: [PlaylistTrack_update_column!]! = [] + where: PlaylistTrack_bool_exp +} + +"Ordering options when selecting data from \"PlaylistTrack\"." +input PlaylistTrack_order_by { + Playlist: Playlist_order_by + PlaylistId: order_by + Track: Track_order_by + TrackId: order_by +} + +"primary key columns input for table: PlaylistTrack" +input PlaylistTrack_pk_columns_input { + PlaylistId: Int! + TrackId: Int! +} + +"select columns of table \"PlaylistTrack\"" +enum PlaylistTrack_select_column { + "column name" PlaylistId + "column name" TrackId +} + +"input type for updating data in table \"PlaylistTrack\"" +input PlaylistTrack_set_input { + PlaylistId: Int + TrackId: Int +} + +"aggregate stddev on columns" +type PlaylistTrack_stddev_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate stddev_pop on columns" +type PlaylistTrack_stddev_pop_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev_pop() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_pop_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate stddev_samp on columns" +type PlaylistTrack_stddev_samp_fields { + PlaylistId: Float + TrackId: Float +} + +"order by stddev_samp() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_stddev_samp_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"Streaming cursor of the table \"PlaylistTrack\"" +input PlaylistTrack_stream_cursor_input { + "Stream column input with initial value" initial_value: PlaylistTrack_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input PlaylistTrack_stream_cursor_value_input { + PlaylistId: Int + TrackId: Int +} + +"aggregate sum on columns" +type PlaylistTrack_sum_fields { + PlaylistId: Int + TrackId: Int +} + +"order by sum() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_sum_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"update columns of table \"PlaylistTrack\"" +enum PlaylistTrack_update_column { + "column name" PlaylistId + "column name" TrackId +} + +input PlaylistTrack_updates { + "increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input + "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input + "filter the rows which have to be updated" where: PlaylistTrack_bool_exp! +} + +"aggregate var_pop on columns" +type PlaylistTrack_var_pop_fields { + PlaylistId: Float + TrackId: Float +} + +"order by var_pop() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_var_pop_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate var_samp on columns" +type PlaylistTrack_var_samp_fields { + PlaylistId: Float + TrackId: Float +} + +"order by var_samp() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_var_samp_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregate variance on columns" +type PlaylistTrack_variance_fields { + PlaylistId: Float + TrackId: Float +} + +"order by variance() on columns of table \"PlaylistTrack\"" +input PlaylistTrack_variance_order_by { + PlaylistId: order_by + TrackId: order_by +} + +"aggregated selection of \"Playlist\"" +type Playlist_aggregate { + aggregate: Playlist_aggregate_fields + nodes: [Playlist!]! +} + +"aggregate fields of \"Playlist\"" +type Playlist_aggregate_fields { + avg: Playlist_avg_fields + count(columns: [Playlist_select_column!], distinct: Boolean): Int! + max: Playlist_max_fields + min: Playlist_min_fields + stddev: Playlist_stddev_fields + stddev_pop: Playlist_stddev_pop_fields + stddev_samp: Playlist_stddev_samp_fields + sum: Playlist_sum_fields + var_pop: Playlist_var_pop_fields + var_samp: Playlist_var_samp_fields + variance: Playlist_variance_fields +} + +"aggregate avg on columns" +type Playlist_avg_fields { + PlaylistId: Float +} + +"Boolean expression to filter rows from the table \"Playlist\". All fields are combined with a logical 'AND'." +input Playlist_bool_exp { + Name: String_comparison_exp + PlaylistId: Int_comparison_exp + PlaylistTracks: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: PlaylistTrack_aggregate_bool_exp + _and: [Playlist_bool_exp!] + _not: Playlist_bool_exp + _or: [Playlist_bool_exp!] +} + +"unique or primary key constraints on table \"Playlist\"" +enum Playlist_constraint { + "unique or primary key constraint on columns \"PlaylistId\"" PK_Playlist +} + +"input type for inserting data into table \"Playlist\"" +input Playlist_insert_input { + Name: String + PlaylistTracks: PlaylistTrack_arr_rel_insert_input +} + +"aggregate max on columns" +type Playlist_max_fields { + Name: String + PlaylistId: Int +} + +"aggregate min on columns" +type Playlist_min_fields { + Name: String + PlaylistId: Int +} + +"response of any mutation on the table \"Playlist\"" +type Playlist_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Playlist!]! +} + +"input type for inserting object relation for remote table \"Playlist\"" +input Playlist_obj_rel_insert_input { + data: Playlist_insert_input! + "upsert condition" on_conflict: Playlist_on_conflict +} + +"on_conflict condition type for table \"Playlist\"" +input Playlist_on_conflict { + constraint: Playlist_constraint! + update_columns: [Playlist_update_column!]! = [] + where: Playlist_bool_exp +} + +"Ordering options when selecting data from \"Playlist\"." +input Playlist_order_by { + Name: order_by + PlaylistId: order_by + PlaylistTracks_aggregate: PlaylistTrack_aggregate_order_by +} + +"primary key columns input for table: Playlist" +input Playlist_pk_columns_input { + PlaylistId: Int! +} + +"select columns of table \"Playlist\"" +enum Playlist_select_column { + "column name" Name + "column name" PlaylistId +} + +"input type for updating data in table \"Playlist\"" +input Playlist_set_input { + Name: String +} + +"aggregate stddev on columns" +type Playlist_stddev_fields { + PlaylistId: Float +} + +"aggregate stddev_pop on columns" +type Playlist_stddev_pop_fields { + PlaylistId: Float +} + +"aggregate stddev_samp on columns" +type Playlist_stddev_samp_fields { + PlaylistId: Float +} + +"Streaming cursor of the table \"Playlist\"" +input Playlist_stream_cursor_input { + "Stream column input with initial value" initial_value: Playlist_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Playlist_stream_cursor_value_input { + Name: String + PlaylistId: Int +} + +"aggregate sum on columns" +type Playlist_sum_fields { + PlaylistId: Int +} + +"update columns of table \"Playlist\"" +enum Playlist_update_column { + "column name" Name +} + +input Playlist_updates { + "sets the columns of the filtered rows to the given values" _set: Playlist_set_input + "filter the rows which have to be updated" where: Playlist_bool_exp! +} + +"aggregate var_pop on columns" +type Playlist_var_pop_fields { + PlaylistId: Float +} + +"aggregate var_samp on columns" +type Playlist_var_samp_fields { + PlaylistId: Float +} + +"aggregate variance on columns" +type Playlist_variance_fields { + PlaylistId: Float +} + +scalar String + +"Boolean expression to compare columns of type \"String\". All fields are combined with logical 'AND'." +input String_comparison_exp { + _eq: String + _gt: String + _gte: String + "does the column match the given case-insensitive pattern" _ilike: String + _in: [String!] + "does the column match the given POSIX regular expression, case insensitive" _iregex: String + _is_null: Boolean + "does the column match the given pattern" _like: String + _lt: String + _lte: String + _neq: String + "does the column NOT match the given case-insensitive pattern" _nilike: String + _nin: [String!] + "does the column NOT match the given POSIX regular expression, case insensitive" _niregex: String + "does the column NOT match the given pattern" _nlike: String + "does the column NOT match the given POSIX regular expression, case sensitive" _nregex: String + "does the column NOT match the given SQL regular expression" _nsimilar: String + "does the column match the given POSIX regular expression, case sensitive" _regex: String + "does the column match the given SQL regular expression" _similar: String +} + +"columns and relationships of \"Track\"" +type Track { + "An object relationship" + Album: Album + AlbumId: Int + Bytes: Int + Composer: String + "An object relationship" + Genre: Genre + GenreId: Int + "An array relationship" + InvoiceLines("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "An aggregate relationship" + InvoiceLines_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "An object relationship" + MediaType: MediaType! + MediaTypeId: Int! + Milliseconds: Int! + Name: String! + "An array relationship" + PlaylistTracks("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "An aggregate relationship" + PlaylistTracks_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + TrackId: Int! + UnitPrice: numeric! +} + +"aggregated selection of \"Track\"" +type Track_aggregate { + aggregate: Track_aggregate_fields + nodes: [Track!]! +} + +input Track_aggregate_bool_exp { + count: Track_aggregate_bool_exp_count +} + +input Track_aggregate_bool_exp_count { + arguments: [Track_select_column!] + distinct: Boolean + filter: Track_bool_exp + predicate: Int_comparison_exp! +} + +"aggregate fields of \"Track\"" +type Track_aggregate_fields { + avg: Track_avg_fields + count(columns: [Track_select_column!], distinct: Boolean): Int! + max: Track_max_fields + min: Track_min_fields + stddev: Track_stddev_fields + stddev_pop: Track_stddev_pop_fields + stddev_samp: Track_stddev_samp_fields + sum: Track_sum_fields + var_pop: Track_var_pop_fields + var_samp: Track_var_samp_fields + variance: Track_variance_fields +} + +"order by aggregate values of table \"Track\"" +input Track_aggregate_order_by { + avg: Track_avg_order_by + count: order_by + max: Track_max_order_by + min: Track_min_order_by + stddev: Track_stddev_order_by + stddev_pop: Track_stddev_pop_order_by + stddev_samp: Track_stddev_samp_order_by + sum: Track_sum_order_by + var_pop: Track_var_pop_order_by + var_samp: Track_var_samp_order_by + variance: Track_variance_order_by +} + +"input type for inserting array relation for remote table \"Track\"" +input Track_arr_rel_insert_input { + data: [Track_insert_input!]! + "upsert condition" on_conflict: Track_on_conflict +} + +"aggregate avg on columns" +type Track_avg_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by avg() on columns of table \"Track\"" +input Track_avg_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Boolean expression to filter rows from the table \"Track\". All fields are combined with a logical 'AND'." +input Track_bool_exp { + Album: Album_bool_exp + AlbumId: Int_comparison_exp + Bytes: Int_comparison_exp + Composer: String_comparison_exp + Genre: Genre_bool_exp + GenreId: Int_comparison_exp + InvoiceLines: InvoiceLine_bool_exp + InvoiceLines_aggregate: InvoiceLine_aggregate_bool_exp + MediaType: MediaType_bool_exp + MediaTypeId: Int_comparison_exp + Milliseconds: Int_comparison_exp + Name: String_comparison_exp + PlaylistTracks: PlaylistTrack_bool_exp + PlaylistTracks_aggregate: PlaylistTrack_aggregate_bool_exp + TrackId: Int_comparison_exp + UnitPrice: numeric_comparison_exp + _and: [Track_bool_exp!] + _not: Track_bool_exp + _or: [Track_bool_exp!] +} + +"unique or primary key constraints on table \"Track\"" +enum Track_constraint { + "unique or primary key constraint on columns \"TrackId\"" PK_Track +} + +"input type for incrementing numeric columns in table \"Track\"" +input Track_inc_input { + AlbumId: Int + Bytes: Int + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + UnitPrice: numeric +} + +"input type for inserting data into table \"Track\"" +input Track_insert_input { + Album: Album_obj_rel_insert_input + AlbumId: Int + Bytes: Int + Composer: String + Genre: Genre_obj_rel_insert_input + GenreId: Int + InvoiceLines: InvoiceLine_arr_rel_insert_input + MediaType: MediaType_obj_rel_insert_input + MediaTypeId: Int + Milliseconds: Int + Name: String + PlaylistTracks: PlaylistTrack_arr_rel_insert_input + UnitPrice: numeric +} + +"aggregate max on columns" +type Track_max_fields { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"order by max() on columns of table \"Track\"" +input Track_max_order_by { + AlbumId: order_by + Bytes: order_by + Composer: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate min on columns" +type Track_min_fields { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"order by min() on columns of table \"Track\"" +input Track_min_order_by { + AlbumId: order_by + Bytes: order_by + Composer: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + TrackId: order_by + UnitPrice: order_by +} + +"response of any mutation on the table \"Track\"" +type Track_mutation_response { + "number of rows affected by the mutation" + affected_rows: Int! + "data from the rows affected by the mutation" + returning: [Track!]! +} + +"input type for inserting object relation for remote table \"Track\"" +input Track_obj_rel_insert_input { + data: Track_insert_input! + "upsert condition" on_conflict: Track_on_conflict +} + +"on_conflict condition type for table \"Track\"" +input Track_on_conflict { + constraint: Track_constraint! + update_columns: [Track_update_column!]! = [] + where: Track_bool_exp +} + +"Ordering options when selecting data from \"Track\"." +input Track_order_by { + Album: Album_order_by + AlbumId: order_by + Bytes: order_by + Composer: order_by + Genre: Genre_order_by + GenreId: order_by + InvoiceLines_aggregate: InvoiceLine_aggregate_order_by + MediaType: MediaType_order_by + MediaTypeId: order_by + Milliseconds: order_by + Name: order_by + PlaylistTracks_aggregate: PlaylistTrack_aggregate_order_by + TrackId: order_by + UnitPrice: order_by +} + +"primary key columns input for table: Track" +input Track_pk_columns_input { + TrackId: Int! +} + +"select columns of table \"Track\"" +enum Track_select_column { + "column name" AlbumId + "column name" Bytes + "column name" Composer + "column name" GenreId + "column name" MediaTypeId + "column name" Milliseconds + "column name" Name + "column name" TrackId + "column name" UnitPrice +} + +"input type for updating data in table \"Track\"" +input Track_set_input { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + UnitPrice: numeric +} + +"aggregate stddev on columns" +type Track_stddev_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev() on columns of table \"Track\"" +input Track_stddev_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_pop on columns" +type Track_stddev_pop_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_pop() on columns of table \"Track\"" +input Track_stddev_pop_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate stddev_samp on columns" +type Track_stddev_samp_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by stddev_samp() on columns of table \"Track\"" +input Track_stddev_samp_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"Streaming cursor of the table \"Track\"" +input Track_stream_cursor_input { + "Stream column input with initial value" initial_value: Track_stream_cursor_value_input! + "cursor ordering" ordering: cursor_ordering +} + +"Initial value of the column from where the streaming should start" +input Track_stream_cursor_value_input { + AlbumId: Int + Bytes: Int + Composer: String + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + Name: String + TrackId: Int + UnitPrice: numeric +} + +"aggregate sum on columns" +type Track_sum_fields { + AlbumId: Int + Bytes: Int + GenreId: Int + MediaTypeId: Int + Milliseconds: Int + TrackId: Int + UnitPrice: numeric +} + +"order by sum() on columns of table \"Track\"" +input Track_sum_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"update columns of table \"Track\"" +enum Track_update_column { + "column name" AlbumId + "column name" Bytes + "column name" Composer + "column name" GenreId + "column name" MediaTypeId + "column name" Milliseconds + "column name" Name + "column name" UnitPrice +} + +input Track_updates { + "increments the numeric columns with given value of the filtered values" _inc: Track_inc_input + "sets the columns of the filtered rows to the given values" _set: Track_set_input + "filter the rows which have to be updated" where: Track_bool_exp! +} + +"aggregate var_pop on columns" +type Track_var_pop_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_pop() on columns of table \"Track\"" +input Track_var_pop_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate var_samp on columns" +type Track_var_samp_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by var_samp() on columns of table \"Track\"" +input Track_var_samp_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"aggregate variance on columns" +type Track_variance_fields { + AlbumId: Float + Bytes: Float + GenreId: Float + MediaTypeId: Float + Milliseconds: Float + TrackId: Float + UnitPrice: Float +} + +"order by variance() on columns of table \"Track\"" +input Track_variance_order_by { + AlbumId: order_by + Bytes: order_by + GenreId: order_by + MediaTypeId: order_by + Milliseconds: order_by + TrackId: order_by + UnitPrice: order_by +} + +"ordering argument of a cursor" +enum cursor_ordering { + "ascending ordering of the cursor" ASC + "descending ordering of the cursor" DESC +} + +"mutation root" +type mutation_root { + "delete data from the table: \"Album\"" + delete_Album("filter the rows which have to be deleted" where: Album_bool_exp!): Album_mutation_response + "delete single row from the table: \"Album\"" + delete_Album_by_pk(AlbumId: Int!): Album + "delete data from the table: \"Artist\"" + delete_Artist("filter the rows which have to be deleted" where: Artist_bool_exp!): Artist_mutation_response + "delete single row from the table: \"Artist\"" + delete_Artist_by_pk(ArtistId: Int!): Artist + "delete data from the table: \"Customer\"" + delete_Customer("filter the rows which have to be deleted" where: Customer_bool_exp!): Customer_mutation_response + "delete single row from the table: \"Customer\"" + delete_Customer_by_pk(CustomerId: Int!): Customer + "delete data from the table: \"Employee\"" + delete_Employee("filter the rows which have to be deleted" where: Employee_bool_exp!): Employee_mutation_response + "delete single row from the table: \"Employee\"" + delete_Employee_by_pk(EmployeeId: Int!): Employee + "delete data from the table: \"Genre\"" + delete_Genre("filter the rows which have to be deleted" where: Genre_bool_exp!): Genre_mutation_response + "delete single row from the table: \"Genre\"" + delete_Genre_by_pk(GenreId: Int!): Genre + "delete data from the table: \"Invoice\"" + delete_Invoice("filter the rows which have to be deleted" where: Invoice_bool_exp!): Invoice_mutation_response + "delete data from the table: \"InvoiceLine\"" + delete_InvoiceLine("filter the rows which have to be deleted" where: InvoiceLine_bool_exp!): InvoiceLine_mutation_response + "delete single row from the table: \"InvoiceLine\"" + delete_InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "delete single row from the table: \"Invoice\"" + delete_Invoice_by_pk(InvoiceId: Int!): Invoice + "delete data from the table: \"MediaType\"" + delete_MediaType("filter the rows which have to be deleted" where: MediaType_bool_exp!): MediaType_mutation_response + "delete single row from the table: \"MediaType\"" + delete_MediaType_by_pk(MediaTypeId: Int!): MediaType + "delete data from the table: \"Playlist\"" + delete_Playlist("filter the rows which have to be deleted" where: Playlist_bool_exp!): Playlist_mutation_response + "delete data from the table: \"PlaylistTrack\"" + delete_PlaylistTrack("filter the rows which have to be deleted" where: PlaylistTrack_bool_exp!): PlaylistTrack_mutation_response + "delete single row from the table: \"PlaylistTrack\"" + delete_PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "delete single row from the table: \"Playlist\"" + delete_Playlist_by_pk(PlaylistId: Int!): Playlist + "delete data from the table: \"Track\"" + delete_Track("filter the rows which have to be deleted" where: Track_bool_exp!): Track_mutation_response + "delete single row from the table: \"Track\"" + delete_Track_by_pk(TrackId: Int!): Track + "insert data into the table: \"Album\"" + insert_Album("the rows to be inserted" objects: [Album_insert_input!]!, "upsert condition" on_conflict: Album_on_conflict): Album_mutation_response + "insert a single row into the table: \"Album\"" + insert_Album_one("the row to be inserted" object: Album_insert_input!, "upsert condition" on_conflict: Album_on_conflict): Album + "insert data into the table: \"Artist\"" + insert_Artist("the rows to be inserted" objects: [Artist_insert_input!]!, "upsert condition" on_conflict: Artist_on_conflict): Artist_mutation_response + "insert a single row into the table: \"Artist\"" + insert_Artist_one("the row to be inserted" object: Artist_insert_input!, "upsert condition" on_conflict: Artist_on_conflict): Artist + "insert data into the table: \"Customer\"" + insert_Customer("the rows to be inserted" objects: [Customer_insert_input!]!, "upsert condition" on_conflict: Customer_on_conflict): Customer_mutation_response + "insert a single row into the table: \"Customer\"" + insert_Customer_one("the row to be inserted" object: Customer_insert_input!, "upsert condition" on_conflict: Customer_on_conflict): Customer + "insert data into the table: \"Employee\"" + insert_Employee("the rows to be inserted" objects: [Employee_insert_input!]!, "upsert condition" on_conflict: Employee_on_conflict): Employee_mutation_response + "insert a single row into the table: \"Employee\"" + insert_Employee_one("the row to be inserted" object: Employee_insert_input!, "upsert condition" on_conflict: Employee_on_conflict): Employee + "insert data into the table: \"Genre\"" + insert_Genre("the rows to be inserted" objects: [Genre_insert_input!]!, "upsert condition" on_conflict: Genre_on_conflict): Genre_mutation_response + "insert a single row into the table: \"Genre\"" + insert_Genre_one("the row to be inserted" object: Genre_insert_input!, "upsert condition" on_conflict: Genre_on_conflict): Genre + "insert data into the table: \"Invoice\"" + insert_Invoice("the rows to be inserted" objects: [Invoice_insert_input!]!, "upsert condition" on_conflict: Invoice_on_conflict): Invoice_mutation_response + "insert data into the table: \"InvoiceLine\"" + insert_InvoiceLine("the rows to be inserted" objects: [InvoiceLine_insert_input!]!, "upsert condition" on_conflict: InvoiceLine_on_conflict): InvoiceLine_mutation_response + "insert a single row into the table: \"InvoiceLine\"" + insert_InvoiceLine_one("the row to be inserted" object: InvoiceLine_insert_input!, "upsert condition" on_conflict: InvoiceLine_on_conflict): InvoiceLine + "insert a single row into the table: \"Invoice\"" + insert_Invoice_one("the row to be inserted" object: Invoice_insert_input!, "upsert condition" on_conflict: Invoice_on_conflict): Invoice + "insert data into the table: \"MediaType\"" + insert_MediaType("the rows to be inserted" objects: [MediaType_insert_input!]!, "upsert condition" on_conflict: MediaType_on_conflict): MediaType_mutation_response + "insert a single row into the table: \"MediaType\"" + insert_MediaType_one("the row to be inserted" object: MediaType_insert_input!, "upsert condition" on_conflict: MediaType_on_conflict): MediaType + "insert data into the table: \"Playlist\"" + insert_Playlist("the rows to be inserted" objects: [Playlist_insert_input!]!, "upsert condition" on_conflict: Playlist_on_conflict): Playlist_mutation_response + "insert data into the table: \"PlaylistTrack\"" + insert_PlaylistTrack("the rows to be inserted" objects: [PlaylistTrack_insert_input!]!, "upsert condition" on_conflict: PlaylistTrack_on_conflict): PlaylistTrack_mutation_response + "insert a single row into the table: \"PlaylistTrack\"" + insert_PlaylistTrack_one("the row to be inserted" object: PlaylistTrack_insert_input!, "upsert condition" on_conflict: PlaylistTrack_on_conflict): PlaylistTrack + "insert a single row into the table: \"Playlist\"" + insert_Playlist_one("the row to be inserted" object: Playlist_insert_input!, "upsert condition" on_conflict: Playlist_on_conflict): Playlist + "insert data into the table: \"Track\"" + insert_Track("the rows to be inserted" objects: [Track_insert_input!]!, "upsert condition" on_conflict: Track_on_conflict): Track_mutation_response + "insert a single row into the table: \"Track\"" + insert_Track_one("the row to be inserted" object: Track_insert_input!, "upsert condition" on_conflict: Track_on_conflict): Track + "update data of the table: \"Album\"" + update_Album("increments the numeric columns with given value of the filtered values" _inc: Album_inc_input, "sets the columns of the filtered rows to the given values" _set: Album_set_input, "filter the rows which have to be updated" where: Album_bool_exp!): Album_mutation_response + "update single row of the table: \"Album\"" + update_Album_by_pk("increments the numeric columns with given value of the filtered values" _inc: Album_inc_input, "sets the columns of the filtered rows to the given values" _set: Album_set_input, pk_columns: Album_pk_columns_input!): Album + "update multiples rows of table: \"Album\"" + update_Album_many("updates to execute, in order" updates: [Album_updates!]!): [Album_mutation_response] + "update data of the table: \"Artist\"" + update_Artist("sets the columns of the filtered rows to the given values" _set: Artist_set_input, "filter the rows which have to be updated" where: Artist_bool_exp!): Artist_mutation_response + "update single row of the table: \"Artist\"" + update_Artist_by_pk("sets the columns of the filtered rows to the given values" _set: Artist_set_input, pk_columns: Artist_pk_columns_input!): Artist + "update multiples rows of table: \"Artist\"" + update_Artist_many("updates to execute, in order" updates: [Artist_updates!]!): [Artist_mutation_response] + "update data of the table: \"Customer\"" + update_Customer("increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input, "sets the columns of the filtered rows to the given values" _set: Customer_set_input, "filter the rows which have to be updated" where: Customer_bool_exp!): Customer_mutation_response + "update single row of the table: \"Customer\"" + update_Customer_by_pk("increments the numeric columns with given value of the filtered values" _inc: Customer_inc_input, "sets the columns of the filtered rows to the given values" _set: Customer_set_input, pk_columns: Customer_pk_columns_input!): Customer + "update multiples rows of table: \"Customer\"" + update_Customer_many("updates to execute, in order" updates: [Customer_updates!]!): [Customer_mutation_response] + "update data of the table: \"Employee\"" + update_Employee("increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input, "sets the columns of the filtered rows to the given values" _set: Employee_set_input, "filter the rows which have to be updated" where: Employee_bool_exp!): Employee_mutation_response + "update single row of the table: \"Employee\"" + update_Employee_by_pk("increments the numeric columns with given value of the filtered values" _inc: Employee_inc_input, "sets the columns of the filtered rows to the given values" _set: Employee_set_input, pk_columns: Employee_pk_columns_input!): Employee + "update multiples rows of table: \"Employee\"" + update_Employee_many("updates to execute, in order" updates: [Employee_updates!]!): [Employee_mutation_response] + "update data of the table: \"Genre\"" + update_Genre("sets the columns of the filtered rows to the given values" _set: Genre_set_input, "filter the rows which have to be updated" where: Genre_bool_exp!): Genre_mutation_response + "update single row of the table: \"Genre\"" + update_Genre_by_pk("sets the columns of the filtered rows to the given values" _set: Genre_set_input, pk_columns: Genre_pk_columns_input!): Genre + "update multiples rows of table: \"Genre\"" + update_Genre_many("updates to execute, in order" updates: [Genre_updates!]!): [Genre_mutation_response] + "update data of the table: \"Invoice\"" + update_Invoice("increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input, "sets the columns of the filtered rows to the given values" _set: Invoice_set_input, "filter the rows which have to be updated" where: Invoice_bool_exp!): Invoice_mutation_response + "update data of the table: \"InvoiceLine\"" + update_InvoiceLine("increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input, "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input, "filter the rows which have to be updated" where: InvoiceLine_bool_exp!): InvoiceLine_mutation_response + "update single row of the table: \"InvoiceLine\"" + update_InvoiceLine_by_pk("increments the numeric columns with given value of the filtered values" _inc: InvoiceLine_inc_input, "sets the columns of the filtered rows to the given values" _set: InvoiceLine_set_input, pk_columns: InvoiceLine_pk_columns_input!): InvoiceLine + "update multiples rows of table: \"InvoiceLine\"" + update_InvoiceLine_many("updates to execute, in order" updates: [InvoiceLine_updates!]!): [InvoiceLine_mutation_response] + "update single row of the table: \"Invoice\"" + update_Invoice_by_pk("increments the numeric columns with given value of the filtered values" _inc: Invoice_inc_input, "sets the columns of the filtered rows to the given values" _set: Invoice_set_input, pk_columns: Invoice_pk_columns_input!): Invoice + "update multiples rows of table: \"Invoice\"" + update_Invoice_many("updates to execute, in order" updates: [Invoice_updates!]!): [Invoice_mutation_response] + "update data of the table: \"MediaType\"" + update_MediaType("sets the columns of the filtered rows to the given values" _set: MediaType_set_input, "filter the rows which have to be updated" where: MediaType_bool_exp!): MediaType_mutation_response + "update single row of the table: \"MediaType\"" + update_MediaType_by_pk("sets the columns of the filtered rows to the given values" _set: MediaType_set_input, pk_columns: MediaType_pk_columns_input!): MediaType + "update multiples rows of table: \"MediaType\"" + update_MediaType_many("updates to execute, in order" updates: [MediaType_updates!]!): [MediaType_mutation_response] + "update data of the table: \"Playlist\"" + update_Playlist("sets the columns of the filtered rows to the given values" _set: Playlist_set_input, "filter the rows which have to be updated" where: Playlist_bool_exp!): Playlist_mutation_response + "update data of the table: \"PlaylistTrack\"" + update_PlaylistTrack("increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input, "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input, "filter the rows which have to be updated" where: PlaylistTrack_bool_exp!): PlaylistTrack_mutation_response + "update single row of the table: \"PlaylistTrack\"" + update_PlaylistTrack_by_pk("increments the numeric columns with given value of the filtered values" _inc: PlaylistTrack_inc_input, "sets the columns of the filtered rows to the given values" _set: PlaylistTrack_set_input, pk_columns: PlaylistTrack_pk_columns_input!): PlaylistTrack + "update multiples rows of table: \"PlaylistTrack\"" + update_PlaylistTrack_many("updates to execute, in order" updates: [PlaylistTrack_updates!]!): [PlaylistTrack_mutation_response] + "update single row of the table: \"Playlist\"" + update_Playlist_by_pk("sets the columns of the filtered rows to the given values" _set: Playlist_set_input, pk_columns: Playlist_pk_columns_input!): Playlist + "update multiples rows of table: \"Playlist\"" + update_Playlist_many("updates to execute, in order" updates: [Playlist_updates!]!): [Playlist_mutation_response] + "update data of the table: \"Track\"" + update_Track("increments the numeric columns with given value of the filtered values" _inc: Track_inc_input, "sets the columns of the filtered rows to the given values" _set: Track_set_input, "filter the rows which have to be updated" where: Track_bool_exp!): Track_mutation_response + "update single row of the table: \"Track\"" + update_Track_by_pk("increments the numeric columns with given value of the filtered values" _inc: Track_inc_input, "sets the columns of the filtered rows to the given values" _set: Track_set_input, pk_columns: Track_pk_columns_input!): Track + "update multiples rows of table: \"Track\"" + update_Track_many("updates to execute, in order" updates: [Track_updates!]!): [Track_mutation_response] +} + +scalar numeric + +"Boolean expression to compare columns of type \"numeric\". All fields are combined with logical 'AND'." +input numeric_comparison_exp { + _eq: numeric + _gt: numeric + _gte: numeric + _in: [numeric!] + _is_null: Boolean + _lt: numeric + _lte: numeric + _neq: numeric + _nin: [numeric!] +} + +"column ordering options" +enum order_by { + "in ascending order, nulls last" asc + "in ascending order, nulls first" asc_nulls_first + "in ascending order, nulls last" asc_nulls_last + "in descending order, nulls first" desc + "in descending order, nulls first" desc_nulls_first + "in descending order, nulls last" desc_nulls_last +} + +type query_root { + "fetch data from the table: \"Album\"" + Album("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch aggregated fields from the table: \"Album\"" + Album_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + "fetch data from the table: \"Album\" using primary key columns" + Album_by_pk(AlbumId: Int!): Album + "fetch data from the table: \"Artist\"" + Artist("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch aggregated fields from the table: \"Artist\"" + Artist_aggregate("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): Artist_aggregate! + "fetch data from the table: \"Artist\" using primary key columns" + Artist_by_pk(ArtistId: Int!): Artist + "fetch data from the table: \"Customer\"" + Customer("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch aggregated fields from the table: \"Customer\"" + Customer_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + "fetch data from the table: \"Customer\" using primary key columns" + Customer_by_pk(CustomerId: Int!): Customer + "fetch data from the table: \"Employee\"" + Employee("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch aggregated fields from the table: \"Employee\"" + Employee_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + "fetch data from the table: \"Employee\" using primary key columns" + Employee_by_pk(EmployeeId: Int!): Employee + "fetch data from the table: \"Genre\"" + Genre("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch aggregated fields from the table: \"Genre\"" + Genre_aggregate("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): Genre_aggregate! + "fetch data from the table: \"Genre\" using primary key columns" + Genre_by_pk(GenreId: Int!): Genre + "fetch data from the table: \"Invoice\"" + Invoice("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"InvoiceLine\"" + InvoiceLine("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"InvoiceLine\"" + InvoiceLine_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "fetch data from the table: \"InvoiceLine\" using primary key columns" + InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "fetch aggregated fields from the table: \"Invoice\"" + Invoice_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + "fetch data from the table: \"Invoice\" using primary key columns" + Invoice_by_pk(InvoiceId: Int!): Invoice + "fetch data from the table: \"MediaType\"" + MediaType("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch aggregated fields from the table: \"MediaType\"" + MediaType_aggregate("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): MediaType_aggregate! + "fetch data from the table: \"MediaType\" using primary key columns" + MediaType_by_pk(MediaTypeId: Int!): MediaType + "fetch data from the table: \"Playlist\"" + Playlist("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"PlaylistTrack\"" + PlaylistTrack("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"PlaylistTrack\"" + PlaylistTrack_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + "fetch data from the table: \"PlaylistTrack\" using primary key columns" + PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "fetch aggregated fields from the table: \"Playlist\"" + Playlist_aggregate("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): Playlist_aggregate! + "fetch data from the table: \"Playlist\" using primary key columns" + Playlist_by_pk(PlaylistId: Int!): Playlist + "fetch data from the table: \"Track\"" + Track("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "fetch aggregated fields from the table: \"Track\"" + Track_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! + "fetch data from the table: \"Track\" using primary key columns" + Track_by_pk(TrackId: Int!): Track +} + +type subscription_root { + "fetch data from the table: \"Album\"" + Album("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch aggregated fields from the table: \"Album\"" + Album_aggregate("distinct select on columns" distinct_on: [Album_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Album_order_by!], "filter the rows returned" where: Album_bool_exp): Album_aggregate! + "fetch data from the table: \"Album\" using primary key columns" + Album_by_pk(AlbumId: Int!): Album + "fetch data from the table in a streaming manner: \"Album\"" + Album_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Album_stream_cursor_input]!, "filter the rows returned" where: Album_bool_exp): [Album!]! + "fetch data from the table: \"Artist\"" + Artist("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch aggregated fields from the table: \"Artist\"" + Artist_aggregate("distinct select on columns" distinct_on: [Artist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Artist_order_by!], "filter the rows returned" where: Artist_bool_exp): Artist_aggregate! + "fetch data from the table: \"Artist\" using primary key columns" + Artist_by_pk(ArtistId: Int!): Artist + "fetch data from the table in a streaming manner: \"Artist\"" + Artist_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Artist_stream_cursor_input]!, "filter the rows returned" where: Artist_bool_exp): [Artist!]! + "fetch data from the table: \"Customer\"" + Customer("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch aggregated fields from the table: \"Customer\"" + Customer_aggregate("distinct select on columns" distinct_on: [Customer_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Customer_order_by!], "filter the rows returned" where: Customer_bool_exp): Customer_aggregate! + "fetch data from the table: \"Customer\" using primary key columns" + Customer_by_pk(CustomerId: Int!): Customer + "fetch data from the table in a streaming manner: \"Customer\"" + Customer_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Customer_stream_cursor_input]!, "filter the rows returned" where: Customer_bool_exp): [Customer!]! + "fetch data from the table: \"Employee\"" + Employee("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch aggregated fields from the table: \"Employee\"" + Employee_aggregate("distinct select on columns" distinct_on: [Employee_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Employee_order_by!], "filter the rows returned" where: Employee_bool_exp): Employee_aggregate! + "fetch data from the table: \"Employee\" using primary key columns" + Employee_by_pk(EmployeeId: Int!): Employee + "fetch data from the table in a streaming manner: \"Employee\"" + Employee_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Employee_stream_cursor_input]!, "filter the rows returned" where: Employee_bool_exp): [Employee!]! + "fetch data from the table: \"Genre\"" + Genre("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch aggregated fields from the table: \"Genre\"" + Genre_aggregate("distinct select on columns" distinct_on: [Genre_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Genre_order_by!], "filter the rows returned" where: Genre_bool_exp): Genre_aggregate! + "fetch data from the table: \"Genre\" using primary key columns" + Genre_by_pk(GenreId: Int!): Genre + "fetch data from the table in a streaming manner: \"Genre\"" + Genre_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Genre_stream_cursor_input]!, "filter the rows returned" where: Genre_bool_exp): [Genre!]! + "fetch data from the table: \"Invoice\"" + Invoice("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"InvoiceLine\"" + InvoiceLine("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"InvoiceLine\"" + InvoiceLine_aggregate("distinct select on columns" distinct_on: [InvoiceLine_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [InvoiceLine_order_by!], "filter the rows returned" where: InvoiceLine_bool_exp): InvoiceLine_aggregate! + "fetch data from the table: \"InvoiceLine\" using primary key columns" + InvoiceLine_by_pk(InvoiceLineId: Int!): InvoiceLine + "fetch data from the table in a streaming manner: \"InvoiceLine\"" + InvoiceLine_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [InvoiceLine_stream_cursor_input]!, "filter the rows returned" where: InvoiceLine_bool_exp): [InvoiceLine!]! + "fetch aggregated fields from the table: \"Invoice\"" + Invoice_aggregate("distinct select on columns" distinct_on: [Invoice_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Invoice_order_by!], "filter the rows returned" where: Invoice_bool_exp): Invoice_aggregate! + "fetch data from the table: \"Invoice\" using primary key columns" + Invoice_by_pk(InvoiceId: Int!): Invoice + "fetch data from the table in a streaming manner: \"Invoice\"" + Invoice_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Invoice_stream_cursor_input]!, "filter the rows returned" where: Invoice_bool_exp): [Invoice!]! + "fetch data from the table: \"MediaType\"" + MediaType("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch aggregated fields from the table: \"MediaType\"" + MediaType_aggregate("distinct select on columns" distinct_on: [MediaType_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [MediaType_order_by!], "filter the rows returned" where: MediaType_bool_exp): MediaType_aggregate! + "fetch data from the table: \"MediaType\" using primary key columns" + MediaType_by_pk(MediaTypeId: Int!): MediaType + "fetch data from the table in a streaming manner: \"MediaType\"" + MediaType_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [MediaType_stream_cursor_input]!, "filter the rows returned" where: MediaType_bool_exp): [MediaType!]! + "fetch data from the table: \"Playlist\"" + Playlist("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"PlaylistTrack\"" + PlaylistTrack("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"PlaylistTrack\"" + PlaylistTrack_aggregate("distinct select on columns" distinct_on: [PlaylistTrack_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [PlaylistTrack_order_by!], "filter the rows returned" where: PlaylistTrack_bool_exp): PlaylistTrack_aggregate! + "fetch data from the table: \"PlaylistTrack\" using primary key columns" + PlaylistTrack_by_pk(PlaylistId: Int!, TrackId: Int!): PlaylistTrack + "fetch data from the table in a streaming manner: \"PlaylistTrack\"" + PlaylistTrack_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [PlaylistTrack_stream_cursor_input]!, "filter the rows returned" where: PlaylistTrack_bool_exp): [PlaylistTrack!]! + "fetch aggregated fields from the table: \"Playlist\"" + Playlist_aggregate("distinct select on columns" distinct_on: [Playlist_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Playlist_order_by!], "filter the rows returned" where: Playlist_bool_exp): Playlist_aggregate! + "fetch data from the table: \"Playlist\" using primary key columns" + Playlist_by_pk(PlaylistId: Int!): Playlist + "fetch data from the table in a streaming manner: \"Playlist\"" + Playlist_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Playlist_stream_cursor_input]!, "filter the rows returned" where: Playlist_bool_exp): [Playlist!]! + "fetch data from the table: \"Track\"" + Track("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): [Track!]! + "fetch aggregated fields from the table: \"Track\"" + Track_aggregate("distinct select on columns" distinct_on: [Track_select_column!], "limit the number of rows returned" limit: Int, "skip the first n rows. Use only with order_by" offset: Int, "sort the rows by one or more columns" order_by: [Track_order_by!], "filter the rows returned" where: Track_bool_exp): Track_aggregate! + "fetch data from the table: \"Track\" using primary key columns" + Track_by_pk(TrackId: Int!): Track + "fetch data from the table in a streaming manner: \"Track\"" + Track_stream("maximum number of rows returned in a single batch" batch_size: Int!, "cursor to stream the results returned by the query" cursor: [Track_stream_cursor_input]!, "filter the rows returned" where: Track_bool_exp): [Track!]! +} + +scalar timestamp + +"Boolean expression to compare columns of type \"timestamp\". All fields are combined with logical 'AND'." +input timestamp_comparison_exp { + _eq: timestamp + _gt: timestamp + _gte: timestamp + _in: [timestamp!] + _is_null: Boolean + _lt: timestamp + _lte: timestamp + _neq: timestamp + _nin: [timestamp!] +} + +"whether this query should be included" +directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT + +"whether this query should be skipped" +directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT + +"whether this query should be cached (Hasura Cloud only)" +directive @cached("measured in seconds" ttl: Int! = "60", "refresh the cache entry" refresh: Boolean! = "false") on QUERY From 30d87927fee8be509002b1db6be6f9d5caa3f8fd Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 14:29:36 -0400 Subject: [PATCH 08/11] add insta as dependency --- Cargo.lock | 99 +++++++++++++++++++++++++++++++ Cargo.toml | 5 ++ crates/ndc-graphql-cli/Cargo.toml | 3 + crates/ndc-graphql/Cargo.toml | 4 ++ 4 files changed, 111 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index 09919c5..66fe10a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -250,6 +250,16 @@ version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" +[[package]] +name = "bstr" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40723b8fb387abc38f4f4a37c09073622e41dd12327033091ef8950659e6dc0c" +dependencies = [ + "memchr", + "serde", +] + [[package]] name = "bumpalo" version = "3.16.0" @@ -365,6 +375,18 @@ dependencies = [ "serde_json", ] +[[package]] +name = "console" +version = "0.15.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb" +dependencies = [ + "encode_unicode", + "lazy_static", + "libc", + "windows-sys 0.52.0", +] + [[package]] name = "core-foundation" version = "0.9.4" @@ -462,6 +484,12 @@ version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b" +[[package]] +name = "encode_unicode" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f" + [[package]] name = "encoding_rs" version = "0.8.34" @@ -634,6 +662,19 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9985c9503b412198aa4197559e9a318524ebc4519c229bfa05a535828c950b9d" +[[package]] +name = "globset" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15f1ce686646e7f1e19bf7d5533fe443a45dbfb990e00629110797578b42fb19" +dependencies = [ + "aho-corasick", + "bstr", + "log", + "regex-automata 0.4.6", + "regex-syntax 0.8.3", +] + [[package]] name = "graphql-introspection-query" version = "0.2.0" @@ -987,6 +1028,21 @@ dependencies = [ "serde", ] +[[package]] +name = "insta" +version = "1.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6593a41c7a73841868772495db7dc1e8ecab43bb5c0b6da2059246c4b506ab60" +dependencies = [ + "console", + "globset", + "lazy_static", + "linked-hash-map", + "serde", + "similar", + "walkdir", +] + [[package]] name = "ipnet" version = "2.9.0" @@ -1035,6 +1091,12 @@ version = "0.2.155" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +[[package]] +name = "linked-hash-map" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f" + [[package]] name = "linux-raw-sys" version = "0.4.14" @@ -1131,9 +1193,11 @@ dependencies = [ "glob-match", "graphql-parser", "indexmap 2.2.6", + "insta", "ndc-sdk", "prometheus", "reqwest 0.12.4", + "schemars", "serde", "serde_json", "tokio", @@ -1149,6 +1213,7 @@ dependencies = [ "graphql-introspection-query", "graphql-parser", "graphql_client", + "insta", "schemars", "serde", "serde_json", @@ -1855,6 +1920,15 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + [[package]] name = "schannel" version = "0.1.23" @@ -2043,6 +2117,12 @@ dependencies = [ "libc", ] +[[package]] +name = "similar" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e" + [[package]] name = "slab" version = "0.4.9" @@ -2594,6 +2674,16 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + [[package]] name = "want" version = "0.3.1" @@ -2720,6 +2810,15 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" +[[package]] +name = "winapi-util" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" +dependencies = [ + "windows-sys 0.48.0", +] + [[package]] name = "winapi-x86_64-pc-windows-gnu" version = "0.4.0" diff --git a/Cargo.toml b/Cargo.toml index 8ac62c7..8f78d73 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,3 +4,8 @@ resolver = "2" package.version = "0.1.3" package.edition = "2021" + +# insta performs better in release mode +[profile.dev.package] +insta.opt-level = 3 +similar.opt-level = 3 diff --git a/crates/ndc-graphql-cli/Cargo.toml b/crates/ndc-graphql-cli/Cargo.toml index 354e717..8f33c91 100644 --- a/crates/ndc-graphql-cli/Cargo.toml +++ b/crates/ndc-graphql-cli/Cargo.toml @@ -13,3 +13,6 @@ schemars = "0.8.16" serde = { version = "1.0.197", features = ["derive"] } serde_json = "1.0.114" tokio = { version = "1.36.0", features = ["macros", "rt-multi-thread", "fs"] } + +[dev-dependencies] +insta = { version = "1.40.0", features = ["yaml"] } diff --git a/crates/ndc-graphql/Cargo.toml b/crates/ndc-graphql/Cargo.toml index 7f8ea26..7a19d93 100644 --- a/crates/ndc-graphql/Cargo.toml +++ b/crates/ndc-graphql/Cargo.toml @@ -21,3 +21,7 @@ serde = { version = "1.0.197", features = ["derive"] } serde_json = "1.0.114" tokio = "1.36.0" tracing = "0.1.40" + +[dev-dependencies] +insta = { version = "1.40.0", features = ["yaml", "glob", "json"] } +schemars = "0.8.16" From 24480ff4960f809dc07a5c691739ccc136c6dd90 Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 14:36:39 -0400 Subject: [PATCH 09/11] add changelog --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index e1249cf..280c645 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +- Implement foreach capability. Instead of producing multiple paralel requests, we produce a single, larger request to send to the target endpoint. +- Fix bug where introspection including interfaces would fail to parse in some circumstances +- Config now defaults to asking for a `GRAPHQL_ENDPOINT` env var +- Fix a bug where default values were not parsed as graphql values, and instead used as string literals + ## [0.1.3] - Fix incorrect version being returned by capabilities From d9c5bcfdcd09807d10bb87e4003156a960e0f6be Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 14:39:08 -0400 Subject: [PATCH 10/11] update deps --- Cargo.lock | 780 +++++++++++++++++++++++++++++++---------------------- 1 file changed, 462 insertions(+), 318 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 66fe10a..b5bc242 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,18 +4,18 @@ version = 3 [[package]] name = "addr2line" -version = "0.21.0" +version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" +checksum = "f5fb1d8e4442bd405fdfd1dacb42792696b0cf9cb15882e5d097b742a676d375" dependencies = [ "gimli", ] [[package]] -name = "adler" -version = "1.0.2" +name = "adler2" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" +checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" [[package]] name = "aho-corasick" @@ -43,9 +43,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.14" +version = "0.6.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b" +checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526" dependencies = [ "anstyle", "anstyle-parse", @@ -58,33 +58,33 @@ dependencies = [ [[package]] name = "anstyle" -version = "1.0.7" +version = "1.0.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b" +checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1" [[package]] name = "anstyle-parse" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4" +checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb" dependencies = [ "utf8parse", ] [[package]] name = "anstyle-query" -version = "1.0.3" +version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a64c907d4e79225ac72e2a354c9ce84d50ebb4586dee56c82b3ee73004f537f5" +checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a" dependencies = [ "windows-sys 0.52.0", ] [[package]] name = "anstyle-wincon" -version = "3.0.3" +version = "3.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19" +checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8" dependencies = [ "anstyle", "windows-sys 0.52.0", @@ -92,9 +92,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.86" +version = "1.0.89" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da" +checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6" [[package]] name = "ascii" @@ -121,18 +121,18 @@ checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] name = "async-trait" -version = "0.1.80" +version = "0.1.82" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca" +checksum = "a27b8a3a6e1a44fa4c8baf1f653e4172e81486d4941f2237e20dc2d0cf4ddff1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -154,7 +154,7 @@ dependencies = [ "futures-util", "http 0.2.12", "http-body 0.4.6", - "hyper 0.14.28", + "hyper 0.14.30", "itoa", "matchit", "memchr", @@ -166,7 +166,7 @@ dependencies = [ "serde_json", "serde_path_to_error", "serde_urlencoded", - "sync_wrapper", + "sync_wrapper 0.1.2", "tokio", "tower", "tower-layer", @@ -213,17 +213,17 @@ dependencies = [ [[package]] name = "backtrace" -version = "0.3.71" +version = "0.3.74" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" +checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a" dependencies = [ "addr2line", - "cc", "cfg-if", "libc", "miniz_oxide", "object", "rustc-demangle", + "windows-targets 0.52.6", ] [[package]] @@ -246,9 +246,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.5.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" [[package]] name = "bstr" @@ -274,15 +274,18 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.6.0" +version = "1.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" +checksum = "428d9aa8fbc0670b7b8d6030a7fadd0f86151cae55e4dbbece15f3780a3dfaf3" [[package]] name = "cc" -version = "1.0.98" +version = "1.1.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41c270e7540d725e65ac7f1b212ac8ce349719624d7bcff99f8e2e488e8cf03f" +checksum = "07b1695e2c7e8fc85310cde85aeaab7e3097f593c91d209d3f9df76c928100f0" +dependencies = [ + "shlex", +] [[package]] name = "cfg-if" @@ -300,14 +303,14 @@ dependencies = [ "iana-time-zone", "num-traits", "serde", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] name = "clap" -version = "4.5.4" +version = "4.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0" +checksum = "b0956a43b323ac1afaffc053ed5c4b7c1f1800bacd1683c353aabbb752515dd3" dependencies = [ "clap_builder", "clap_derive", @@ -315,9 +318,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.2" +version = "4.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4" +checksum = "4d72166dd41634086d5803a47eb71ae740e61d84709c36f3c34110173db3961b" dependencies = [ "anstream", "anstyle", @@ -327,27 +330,27 @@ dependencies = [ [[package]] name = "clap_derive" -version = "4.5.4" +version = "4.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "528131438037fd55894f62d6e9f068b8f45ac57ffa77517819645d10aed04f64" +checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab" dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] name = "clap_lex" -version = "0.7.0" +version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce" +checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97" [[package]] name = "colorchoice" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422" +checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0" [[package]] name = "combine" @@ -369,7 +372,7 @@ dependencies = [ "glob-match", "graphql-parser", "graphql_client", - "reqwest 0.12.4", + "reqwest 0.12.7", "schemars", "serde", "serde_json", @@ -399,15 +402,15 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.8.6" +version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] name = "crc32fast" -version = "1.4.0" +version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa" +checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3" dependencies = [ "cfg-if", ] @@ -429,9 +432,9 @@ checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80" [[package]] name = "darling" -version = "0.20.9" +version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83b2eb4d90d12bdda5ed17de686c2acb4c57914f8f921b8da7e112b5a36f3fe1" +checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989" dependencies = [ "darling_core", "darling_macro", @@ -439,27 +442,27 @@ dependencies = [ [[package]] name = "darling_core" -version = "0.20.9" +version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "622687fe0bac72a04e5599029151f5796111b90f1baaa9b544d807a5e31cd120" +checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5" dependencies = [ "fnv", "ident_case", "proc-macro2", "quote", "strsim", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] name = "darling_macro" -version = "0.20.9" +version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178" +checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806" dependencies = [ "darling_core", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -480,9 +483,9 @@ checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125" [[package]] name = "either" -version = "1.12.0" +version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b" +checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" [[package]] name = "encode_unicode" @@ -517,15 +520,15 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.1.0" +version = "2.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a" +checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6" [[package]] name = "flate2" -version = "1.0.30" +version = "1.0.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae" +checksum = "324a1be68054ef05ad64b861cc9eaf1d623d2d8cb25b4bf2cb9cdd902b4bf253" dependencies = [ "crc32fast", "miniz_oxide", @@ -601,7 +604,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -646,9 +649,9 @@ dependencies = [ [[package]] name = "gimli" -version = "0.28.1" +version = "0.31.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" +checksum = "32085ea23f3234fc7846555e85283ba4de91e21016dc0455a16286d87a292d64" [[package]] name = "glob" @@ -671,8 +674,8 @@ dependencies = [ "aho-corasick", "bstr", "log", - "regex-automata 0.4.6", - "regex-syntax 0.8.3", + "regex-automata 0.4.7", + "regex-syntax 0.8.4", ] [[package]] @@ -745,7 +748,7 @@ dependencies = [ "futures-sink", "futures-util", "http 0.2.12", - "indexmap 2.2.6", + "indexmap 2.5.0", "slab", "tokio", "tokio-util", @@ -823,9 +826,9 @@ dependencies = [ [[package]] name = "http-body" -version = "1.0.0" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643" +checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" dependencies = [ "bytes", "http 1.1.0", @@ -833,14 +836,14 @@ dependencies = [ [[package]] name = "http-body-util" -version = "0.1.1" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0475f8b2ac86659c21b64320d5d653f9efe42acd2a4e560073ec61a155a34f1d" +checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f" dependencies = [ "bytes", - "futures-core", + "futures-util", "http 1.1.0", - "http-body 1.0.0", + "http-body 1.0.1", "pin-project-lite", ] @@ -852,9 +855,9 @@ checksum = "add0ab9360ddbd88cfeb3bd9574a1d85cfdfa14db10b3e21d3700dbc4328758f" [[package]] name = "httparse" -version = "1.8.0" +version = "1.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" +checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9" [[package]] name = "httpdate" @@ -864,9 +867,9 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" [[package]] name = "hyper" -version = "0.14.28" +version = "0.14.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80" +checksum = "a152ddd61dfaec7273fe8419ab357f33aee0d914c5f4efbf0d96fa749eea5ec9" dependencies = [ "bytes", "futures-channel", @@ -888,15 +891,15 @@ dependencies = [ [[package]] name = "hyper" -version = "1.3.1" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe575dd17d0862a9a33781c8c4696a55c320909004a67a00fb286ba8b1bc496d" +checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05" dependencies = [ "bytes", "futures-channel", "futures-util", "http 1.1.0", - "http-body 1.0.0", + "http-body 1.0.1", "httparse", "itoa", "pin-project-lite", @@ -907,19 +910,20 @@ dependencies = [ [[package]] name = "hyper-rustls" -version = "0.26.0" +version = "0.27.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0bea761b46ae2b24eb4aef630d8d1c398157b6fc29e6350ecf090a0b70c952c" +checksum = "08afdbb5c31130e3034af566421053ab03787c640246a446327f550d11bcb333" dependencies = [ "futures-util", "http 1.1.0", - "hyper 1.3.1", + "hyper 1.4.1", "hyper-util", - "rustls 0.22.4", + "rustls 0.23.13", "rustls-pki-types", "tokio", - "tokio-rustls", + "tokio-rustls 0.26.0", "tower-service", + "webpki-roots", ] [[package]] @@ -928,7 +932,7 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1" dependencies = [ - "hyper 0.14.28", + "hyper 0.14.30", "pin-project-lite", "tokio", "tokio-io-timeout", @@ -941,7 +945,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905" dependencies = [ "bytes", - "hyper 0.14.28", + "hyper 0.14.30", "native-tls", "tokio", "tokio-native-tls", @@ -949,16 +953,16 @@ dependencies = [ [[package]] name = "hyper-util" -version = "0.1.3" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca38ef113da30126bbff9cd1705f9273e15d45498615d138b0c20279ac7a76aa" +checksum = "da62f120a8a37763efb0cf8fdf264b884c7b8b9ac8660b900c8661030c00e6ba" dependencies = [ "bytes", "futures-channel", "futures-util", "http 1.1.0", - "http-body 1.0.0", - "hyper 1.3.1", + "http-body 1.0.1", + "hyper 1.4.1", "pin-project-lite", "socket2", "tokio", @@ -969,9 +973,9 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.60" +version = "0.1.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141" +checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220" dependencies = [ "android_system_properties", "core-foundation-sys", @@ -1019,9 +1023,9 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.2.6" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26" +checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5" dependencies = [ "equivalent", "hashbrown 0.14.5", @@ -1045,15 +1049,15 @@ dependencies = [ [[package]] name = "ipnet" -version = "2.9.0" +version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" +checksum = "187674a687eed5fe42285b40c6291f9a01517d415fad1c3cbc6a9f778af7fcd4" [[package]] name = "is_terminal_polyfill" -version = "1.70.0" +version = "1.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800" +checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" [[package]] name = "itertools" @@ -1072,24 +1076,24 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" [[package]] name = "js-sys" -version = "0.3.69" +version = "0.3.70" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d" +checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a" dependencies = [ "wasm-bindgen", ] [[package]] name = "lazy_static" -version = "1.4.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" [[package]] name = "libc" -version = "0.2.155" +version = "0.2.158" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439" [[package]] name = "linked-hash-map" @@ -1115,9 +1119,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.21" +version = "0.4.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" [[package]] name = "matchers" @@ -1136,9 +1140,9 @@ checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94" [[package]] name = "memchr" -version = "2.7.2" +version = "2.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "mime" @@ -1148,31 +1152,31 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" [[package]] name = "miniz_oxide" -version = "0.7.3" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87dfd01fe195c66b572b37921ad8803d010623c0aca821bea2302239d155cdae" +checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1" dependencies = [ - "adler", + "adler2", ] [[package]] name = "mio" -version = "0.8.11" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c" +checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec" dependencies = [ + "hermit-abi", "libc", "wasi", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "native-tls" -version = "0.2.11" +version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e" +checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466" dependencies = [ - "lazy_static", "libc", "log", "openssl", @@ -1192,11 +1196,11 @@ dependencies = [ "common", "glob-match", "graphql-parser", - "indexmap 2.2.6", + "indexmap 2.5.0", "insta", "ndc-sdk", "prometheus", - "reqwest 0.12.4", + "reqwest 0.12.7", "schemars", "serde", "serde_json", @@ -1225,7 +1229,7 @@ name = "ndc-models" version = "0.1.4" source = "git+http://github.com/hasura/ndc-spec.git?tag=v0.1.4#20172e3b2552b78d16dbafcd047f559ced420309" dependencies = [ - "indexmap 2.2.6", + "indexmap 2.5.0", "schemars", "serde", "serde_json", @@ -1289,21 +1293,11 @@ dependencies = [ "autocfg", ] -[[package]] -name = "num_cpus" -version = "1.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" -dependencies = [ - "hermit-abi", - "libc", -] - [[package]] name = "object" -version = "0.32.2" +version = "0.36.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" +checksum = "084f1a5821ac4c651660a94a7153d27ac9d8a53736203f58b31945ded098070a" dependencies = [ "memchr", ] @@ -1316,11 +1310,11 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" [[package]] name = "openssl" -version = "0.10.64" +version = "0.10.66" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f" +checksum = "9529f4786b70a3e8c61e11179af17ab6188ad8d0ded78c5529441ed39d4bd9c1" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "cfg-if", "foreign-types", "libc", @@ -1337,7 +1331,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -1348,9 +1342,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" [[package]] name = "openssl-sys" -version = "0.9.102" +version = "0.9.103" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2" +checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6" dependencies = [ "cc", "libc", @@ -1470,9 +1464,9 @@ dependencies = [ [[package]] name = "ordered-float" -version = "4.2.0" +version = "4.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a76df7075c7d4d01fdcb46c912dd17fba5b60c78ea480b475f2b6ab6f666584e" +checksum = "4a91171844676f8c7990ce64959210cd2eaef32c2612c50f9fae9f8aaa6065a6" dependencies = [ "num-traits", ] @@ -1485,9 +1479,9 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" [[package]] name = "parking_lot" -version = "0.12.2" +version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e4af0ca4f6caed20e900d564c242b8e5d4903fdacf31d3daf527b66fe6f42fb" +checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" dependencies = [ "lock_api", "parking_lot_core", @@ -1503,7 +1497,7 @@ dependencies = [ "libc", "redox_syscall", "smallvec", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -1529,7 +1523,7 @@ checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -1546,9 +1540,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" [[package]] name = "pkg-config" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" +checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2" [[package]] name = "powerfmt" @@ -1558,15 +1552,18 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" [[package]] name = "ppv-lite86" -version = "0.2.17" +version = "0.2.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" +checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04" +dependencies = [ + "zerocopy", +] [[package]] name = "proc-macro2" -version = "1.0.82" +version = "1.0.86" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b" +checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77" dependencies = [ "unicode-ident", ] @@ -1606,7 +1603,7 @@ dependencies = [ "itertools", "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -1615,11 +1612,59 @@ version = "2.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94" +[[package]] +name = "quinn" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c7c5fdde3cdae7203427dc4f0a68fe0ed09833edc525a03456b153b79828684" +dependencies = [ + "bytes", + "pin-project-lite", + "quinn-proto", + "quinn-udp", + "rustc-hash", + "rustls 0.23.13", + "socket2", + "thiserror", + "tokio", + "tracing", +] + +[[package]] +name = "quinn-proto" +version = "0.11.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fadfaed2cd7f389d0161bb73eeb07b7b78f8691047a6f3e73caaeae55310a4a6" +dependencies = [ + "bytes", + "rand", + "ring", + "rustc-hash", + "rustls 0.23.13", + "slab", + "thiserror", + "tinyvec", + "tracing", +] + +[[package]] +name = "quinn-udp" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fe68c2e9e1a1234e218683dbdf9f9dfcb094113c5ac2b938dfcb9bab4c4140b" +dependencies = [ + "libc", + "once_cell", + "socket2", + "tracing", + "windows-sys 0.59.0", +] + [[package]] name = "quote" -version = "1.0.36" +version = "1.0.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" dependencies = [ "proc-macro2", ] @@ -1656,23 +1701,23 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.5.1" +version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "469052894dcb553421e483e4209ee581a45100d31b4018de03e5a7ad86374a7e" +checksum = "0884ad60e090bf1345b93da0a5de8923c93884cd03f40dfcfddd3b4bee661853" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", ] [[package]] name = "regex" -version = "1.10.4" +version = "1.10.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c" +checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619" dependencies = [ "aho-corasick", "memchr", - "regex-automata 0.4.6", - "regex-syntax 0.8.3", + "regex-automata 0.4.7", + "regex-syntax 0.8.4", ] [[package]] @@ -1686,13 +1731,13 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.6" +version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea" +checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df" dependencies = [ "aho-corasick", "memchr", - "regex-syntax 0.8.3", + "regex-syntax 0.8.4", ] [[package]] @@ -1703,9 +1748,9 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" [[package]] name = "regex-syntax" -version = "0.8.3" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" +checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b" [[package]] name = "reqwest" @@ -1721,7 +1766,7 @@ dependencies = [ "h2", "http 0.2.12", "http-body 0.4.6", - "hyper 0.14.28", + "hyper 0.14.30", "hyper-tls", "ipnet", "js-sys", @@ -1736,7 +1781,7 @@ dependencies = [ "serde", "serde_json", "serde_urlencoded", - "sync_wrapper", + "sync_wrapper 0.1.2", "system-configuration", "tokio", "tokio-native-tls", @@ -1745,23 +1790,23 @@ dependencies = [ "wasm-bindgen", "wasm-bindgen-futures", "web-sys", - "winreg 0.50.0", + "winreg", ] [[package]] name = "reqwest" -version = "0.12.4" +version = "0.12.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "566cafdd92868e0939d3fb961bd0dc25fcfaaed179291093b3d43e6b3150ea10" +checksum = "f8f4955649ef5c38cc7f9e8aa41761d48fb9677197daea9984dc54f56aad5e63" dependencies = [ "base64 0.22.1", "bytes", "futures-core", "futures-util", "http 1.1.0", - "http-body 1.0.0", + "http-body 1.0.1", "http-body-util", - "hyper 1.3.1", + "hyper 1.4.1", "hyper-rustls", "hyper-util", "ipnet", @@ -1771,22 +1816,23 @@ dependencies = [ "once_cell", "percent-encoding", "pin-project-lite", - "rustls 0.22.4", - "rustls-pemfile 2.1.2", + "quinn", + "rustls 0.23.13", + "rustls-pemfile 2.1.3", "rustls-pki-types", "serde", "serde_json", "serde_urlencoded", - "sync_wrapper", + "sync_wrapper 1.0.1", "tokio", - "tokio-rustls", + "tokio-rustls 0.26.0", "tower-service", "url", "wasm-bindgen", "wasm-bindgen-futures", "web-sys", "webpki-roots", - "winreg 0.52.0", + "windows-registry", ] [[package]] @@ -1810,13 +1856,19 @@ version = "0.1.24" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" +[[package]] +name = "rustc-hash" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152" + [[package]] name = "rustix" -version = "0.38.34" +version = "0.38.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f" +checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "errno", "libc", "linux-raw-sys", @@ -1844,19 +1896,33 @@ dependencies = [ "log", "ring", "rustls-pki-types", - "rustls-webpki 0.102.4", + "rustls-webpki 0.102.8", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls" +version = "0.23.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2dabaac7466917e566adb06783a81ca48944c6898a1b08b9374106dd671f4c8" +dependencies = [ + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki 0.102.8", "subtle", "zeroize", ] [[package]] name = "rustls-native-certs" -version = "0.7.0" +version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f1fb85efa936c42c6d5fc28d2629bb51e4b2f4b8a5211e297d599cc5a093792" +checksum = "e5bfb394eeed242e909609f56089eecfe5fda225042e8b171791b9c95f5931e5" dependencies = [ "openssl-probe", - "rustls-pemfile 2.1.2", + "rustls-pemfile 2.1.3", "rustls-pki-types", "schannel", "security-framework", @@ -1873,9 +1939,9 @@ dependencies = [ [[package]] name = "rustls-pemfile" -version = "2.1.2" +version = "2.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29993a25686778eb88d4189742cd713c9bce943bc54251a33509dc63cbacf73d" +checksum = "196fe16b00e106300d3e45ecfcb764fa292a535d7326a29a5875c579c7417425" dependencies = [ "base64 0.22.1", "rustls-pki-types", @@ -1883,9 +1949,9 @@ dependencies = [ [[package]] name = "rustls-pki-types" -version = "1.7.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "976295e77ce332211c0d24d92c0e83e50f5c5f046d11082cea19f3df13a3562d" +checksum = "fc0a2ce646f8655401bb81e7927b812614bd5d91dbc968696be50603510fcaf0" [[package]] name = "rustls-webpki" @@ -1899,9 +1965,9 @@ dependencies = [ [[package]] name = "rustls-webpki" -version = "0.102.4" +version = "0.102.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff448f7e92e913c4b7d4c6d8e4540a1724b319b4152b8aef6d4cf8339712b33e" +checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9" dependencies = [ "ring", "rustls-pki-types", @@ -1931,22 +1997,22 @@ dependencies = [ [[package]] name = "schannel" -version = "0.1.23" +version = "0.1.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534" +checksum = "e9aaafd5a2b6e3d657ff009d82fbd630b6bd54dd4eb06f21693925cdf80f9b8b" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] name = "schemars" -version = "0.8.20" +version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0218ceea14babe24a4a5836f86ade86c1effbc198164e619194cb5069187e29" +checksum = "09c024468a378b7e36765cd36702b7a90cc3cba11654f6685c8f233408e89e92" dependencies = [ "dyn-clone", "indexmap 1.9.3", - "indexmap 2.2.6", + "indexmap 2.5.0", "schemars_derive", "serde", "serde_json", @@ -1955,14 +2021,14 @@ dependencies = [ [[package]] name = "schemars_derive" -version = "0.8.20" +version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ed5a1ccce8ff962e31a165d41f6e2a2dd1245099dc4d594f5574a86cd90f4d3" +checksum = "b1eee588578aff73f856ab961cd2f79e36bc45d7ded33a7562adba4667aecc0e" dependencies = [ "proc-macro2", "quote", "serde_derive_internals", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -1983,11 +2049,11 @@ dependencies = [ [[package]] name = "security-framework" -version = "2.11.0" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0" +checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "core-foundation", "core-foundation-sys", "libc", @@ -1996,9 +2062,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.11.0" +version = "2.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "317936bbbd05227752583946b9e66d7ce3b489f84e11a94a510b4437fef407d7" +checksum = "ea4a292869320c0272d7bc55a5a6aafaff59b4f63404a003887b679a2e05b4b6" dependencies = [ "core-foundation-sys", "libc", @@ -2006,22 +2072,22 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.202" +version = "1.0.210" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "226b61a0d411b2ba5ff6d7f73a476ac4f8bb900373459cd00fab8512828ba395" +checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.202" +version = "1.0.210" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6048858004bcff69094cd972ed40a32500f153bd3be9f716b2eed2e8217c4838" +checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -2032,17 +2098,18 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] name = "serde_json" -version = "1.0.117" +version = "1.0.128" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3" +checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8" dependencies = [ - "indexmap 2.2.6", + "indexmap 2.5.0", "itoa", + "memchr", "ryu", "serde", ] @@ -2071,15 +2138,15 @@ dependencies = [ [[package]] name = "serde_with" -version = "3.8.1" +version = "3.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ad483d2ab0149d5a5ebcd9972a3852711e0153d863bf5a5d0391d28883c4a20" +checksum = "69cecfa94848272156ea67b2b1a53f20fc7bc638c4a46d2f8abde08f05f4b857" dependencies = [ "base64 0.22.1", "chrono", "hex", "indexmap 1.9.3", - "indexmap 2.2.6", + "indexmap 2.5.0", "serde", "serde_derive", "serde_json", @@ -2089,14 +2156,14 @@ dependencies = [ [[package]] name = "serde_with_macros" -version = "3.8.1" +version = "3.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65569b702f41443e8bc8bbb1c5779bd0450bbe723b56198980e80ec45780bce2" +checksum = "a8fee4991ef4f274617a51ad4af30519438dacb2f56ac773b08a1922ff743350" dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -2108,6 +2175,12 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + [[package]] name = "signal-hook-registry" version = "1.4.2" @@ -2171,9 +2244,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" [[package]] name = "subtle" -version = "2.5.0" +version = "2.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" [[package]] name = "syn" @@ -2188,9 +2261,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.65" +version = "2.0.77" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2863d96a84c6439701d7a38f9de935ec562c8832cc55d1dde0f513b52fad106" +checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed" dependencies = [ "proc-macro2", "quote", @@ -2203,6 +2276,15 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" +[[package]] +name = "sync_wrapper" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394" +dependencies = [ + "futures-core", +] + [[package]] name = "system-configuration" version = "0.5.1" @@ -2226,34 +2308,35 @@ dependencies = [ [[package]] name = "tempfile" -version = "3.10.1" +version = "3.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1" +checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64" dependencies = [ "cfg-if", "fastrand", + "once_cell", "rustix", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] name = "thiserror" -version = "1.0.61" +version = "1.0.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709" +checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.61" +version = "1.0.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533" +checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -2299,9 +2382,9 @@ dependencies = [ [[package]] name = "tinyvec" -version = "1.6.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" +checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938" dependencies = [ "tinyvec_macros", ] @@ -2314,20 +2397,19 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.37.0" +version = "1.40.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787" +checksum = "e2b070231665d27ad9ec9b8df639893f46727666c6767db40317fbe920a5d998" dependencies = [ "backtrace", "bytes", "libc", "mio", - "num_cpus", "pin-project-lite", "signal-hook-registry", "socket2", "tokio-macros", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] @@ -2342,13 +2424,13 @@ dependencies = [ [[package]] name = "tokio-macros" -version = "2.2.0" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" +checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -2372,11 +2454,22 @@ dependencies = [ "tokio", ] +[[package]] +name = "tokio-rustls" +version = "0.26.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4" +dependencies = [ + "rustls 0.23.13", + "rustls-pki-types", + "tokio", +] + [[package]] name = "tokio-stream" -version = "0.1.15" +version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af" +checksum = "4f4e6ce100d0eb49a2734f8c0812bcd324cf357d21810932c5df6b96ef2b86f1" dependencies = [ "futures-core", "pin-project-lite", @@ -2385,9 +2478,9 @@ dependencies = [ [[package]] name = "tokio-util" -version = "0.7.11" +version = "0.7.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1" +checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a" dependencies = [ "bytes", "futures-core", @@ -2411,16 +2504,16 @@ dependencies = [ "h2", "http 0.2.12", "http-body 0.4.6", - "hyper 0.14.28", + "hyper 0.14.30", "hyper-timeout", "percent-encoding", "pin-project", "prost", "rustls-native-certs", - "rustls-pemfile 2.1.2", + "rustls-pemfile 2.1.3", "rustls-pki-types", "tokio", - "tokio-rustls", + "tokio-rustls 0.25.0", "tokio-stream", "tower", "tower-layer", @@ -2454,7 +2547,7 @@ version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "61c5bb1d698276a2443e5ecfabc1008bf15a36c12e6a7176e7bf089ea9131140" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "bytes", "futures-core", "futures-util", @@ -2470,15 +2563,15 @@ dependencies = [ [[package]] name = "tower-layer" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0" +checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e" [[package]] name = "tower-service" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" +checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" [[package]] name = "tracing" @@ -2500,7 +2593,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -2594,7 +2687,7 @@ checksum = "1f718dfaf347dcb5b983bfc87608144b0bad87970aebcbea5ce44d2a30c08e63" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", ] [[package]] @@ -2605,15 +2698,15 @@ checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" [[package]] name = "unicode-ident" -version = "1.0.12" +version = "1.0.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" +checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe" [[package]] name = "unicode-normalization" -version = "0.1.23" +version = "0.1.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5" +checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956" dependencies = [ "tinyvec", ] @@ -2635,9 +2728,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "url" -version = "2.5.0" +version = "2.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633" +checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c" dependencies = [ "form_urlencoded", "idna", @@ -2652,9 +2745,9 @@ checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" [[package]] name = "utf8parse" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" [[package]] name = "valuable" @@ -2701,34 +2794,35 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" [[package]] name = "wasm-bindgen" -version = "0.2.92" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8" +checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5" dependencies = [ "cfg-if", + "once_cell", "wasm-bindgen-macro", ] [[package]] name = "wasm-bindgen-backend" -version = "0.2.92" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da" +checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b" dependencies = [ "bumpalo", "log", "once_cell", "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-futures" -version = "0.4.42" +version = "0.4.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0" +checksum = "61e9300f63a621e96ed275155c108eb6f843b6a26d053f122ab69724559dc8ed" dependencies = [ "cfg-if", "js-sys", @@ -2738,9 +2832,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro" -version = "0.2.92" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726" +checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -2748,28 +2842,28 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.92" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" +checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836" dependencies = [ "proc-macro2", "quote", - "syn 2.0.65", + "syn 2.0.77", "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.92" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96" +checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484" [[package]] name = "web-sys" -version = "0.3.69" +version = "0.3.70" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef" +checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0" dependencies = [ "js-sys", "wasm-bindgen", @@ -2787,9 +2881,9 @@ dependencies = [ [[package]] name = "webpki-roots" -version = "0.26.1" +version = "0.26.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3de34ae270483955a94f4b21bdaaeb83d508bb84a01435f393818edb0012009" +checksum = "841c67bff177718f1d4dfefde8d8f0e78f9b6589319ba88312f567fc5841a958" dependencies = [ "rustls-pki-types", ] @@ -2816,7 +2910,7 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" dependencies = [ - "windows-sys 0.48.0", + "windows-sys 0.59.0", ] [[package]] @@ -2831,7 +2925,37 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" dependencies = [ - "windows-targets 0.52.5", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-registry" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0" +dependencies = [ + "windows-result", + "windows-strings", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-result" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-strings" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10" +dependencies = [ + "windows-result", + "windows-targets 0.52.6", ] [[package]] @@ -2849,7 +2973,16 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" dependencies = [ - "windows-targets 0.52.5", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", ] [[package]] @@ -2869,18 +3002,18 @@ dependencies = [ [[package]] name = "windows-targets" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" dependencies = [ - "windows_aarch64_gnullvm 0.52.5", - "windows_aarch64_msvc 0.52.5", - "windows_i686_gnu 0.52.5", + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", "windows_i686_gnullvm", - "windows_i686_msvc 0.52.5", - "windows_x86_64_gnu 0.52.5", - "windows_x86_64_gnullvm 0.52.5", - "windows_x86_64_msvc 0.52.5", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", ] [[package]] @@ -2891,9 +3024,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" [[package]] name = "windows_aarch64_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" [[package]] name = "windows_aarch64_msvc" @@ -2903,9 +3036,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" [[package]] name = "windows_aarch64_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" [[package]] name = "windows_i686_gnu" @@ -2915,15 +3048,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" [[package]] name = "windows_i686_gnu" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" [[package]] name = "windows_i686_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" [[package]] name = "windows_i686_msvc" @@ -2933,9 +3066,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" [[package]] name = "windows_i686_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" [[package]] name = "windows_x86_64_gnu" @@ -2945,9 +3078,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" [[package]] name = "windows_x86_64_gnu" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" [[package]] name = "windows_x86_64_gnullvm" @@ -2957,9 +3090,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" [[package]] name = "windows_x86_64_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" [[package]] name = "windows_x86_64_msvc" @@ -2969,9 +3102,9 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" [[package]] name = "windows_x86_64_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" [[package]] name = "winreg" @@ -2984,17 +3117,28 @@ dependencies = [ ] [[package]] -name = "winreg" -version = "0.52.0" +name = "zerocopy" +version = "0.7.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a277a57398d4bfa075df44f501a17cfdf8542d224f0d36095a2adc7aee4ef0a5" +checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" dependencies = [ - "cfg-if", - "windows-sys 0.48.0", + "byteorder", + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.7.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.77", ] [[package]] name = "zeroize" -version = "1.7.0" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d" +checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" From 57d183e9db936dd97f224ffc823bca71d079c8e2 Mon Sep 17 00:00:00 2001 From: Benoit Ranque Date: Mon, 23 Sep 2024 17:13:16 -0400 Subject: [PATCH 11/11] fix typo --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 280c645..3c1b32e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,7 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] -- Implement foreach capability. Instead of producing multiple paralel requests, we produce a single, larger request to send to the target endpoint. +- Implement foreach capability. Instead of producing multiple parallel requests, we produce a single, larger request to send to the target endpoint. - Fix bug where introspection including interfaces would fail to parse in some circumstances - Config now defaults to asking for a `GRAPHQL_ENDPOINT` env var - Fix a bug where default values were not parsed as graphql values, and instead used as string literals