# This file was generated based on ".graphqlconfig". Do not edit manually.

schema {
    query: query_root
    mutation: mutation_root
    subscription: subscription_root
}

"whether this query should be cached (Hasura Cloud only)"
directive @cached(
    "refresh the cache entry"
    refresh: Boolean! = false,
    "measured in seconds"
    ttl: Int! = 60
) on QUERY

type ActionMutationPongOutput {
    data: ActionMutationPongOutputData
    errors: [Error]
    nodes: [IdLink]
    response_name: String!
    response_value: Int!
}

type ActionMutationPongOutputData {
    message: String!
    number: Int!
}

type ActionQueryPingOutput {
    data: ActionQueryPingOutputData
    errors: [Error]
    nodes: [IdLink]
    response_name: String!
    response_value: Int!
}

type ActionQueryPingOutputData {
    message: String!
    number: Int!
}

type ActionUploadFileOutput {
    data: ActionUploadFileOutputData
    errors: [Error]
    nodes: [IdLink]
    response_name: String!
    response_value: Int!
}

type ActionUploadFileOutputData {
    file_name: String!
    file_type: String!
    file_url: String!
}

"columns and relationships of \"ENUM_ROLE\""
type ENUM_ROLE {
    comment: String
    value: String!
}

"aggregated selection of \"ENUM_ROLE\""
type ENUM_ROLE_aggregate {
    aggregate: ENUM_ROLE_aggregate_fields
    nodes: [ENUM_ROLE!]!
}

"aggregate fields of \"ENUM_ROLE\""
type ENUM_ROLE_aggregate_fields {
    count(columns: [ENUM_ROLE_select_column!], distinct: Boolean): Int!
    max: ENUM_ROLE_max_fields
    min: ENUM_ROLE_min_fields
}

"aggregate max on columns"
type ENUM_ROLE_max_fields {
    comment: String
    value: String
}

"aggregate min on columns"
type ENUM_ROLE_min_fields {
    comment: String
    value: String
}

"response of any mutation on the table \"ENUM_ROLE\""
type ENUM_ROLE_mutation_response {
    "number of rows affected by the mutation"
    affected_rows: Int!
    "data from the rows affected by the mutation"
    returning: [ENUM_ROLE!]!
}

type Error {
    message: String
}

type IdLink {
    link: String!
    table: String!
}

"fields of action: \"action_upload_file\""
type action_upload_file {
    "the time at which this action was created"
    created_at: timestamptz!
    "errors related to the invocation"
    errors: json
    "the unique id of an action"
    id: uuid!
    "the output fields of this action"
    output: ActionUploadFileOutput
}

"columns and relationships of \"app\""
type app {
    name: String!
    storage_bucket: String!
    version_latest: String!
    version_supported: String!
}

"aggregated selection of \"app\""
type app_aggregate {
    aggregate: app_aggregate_fields
    nodes: [app!]!
}

"aggregate fields of \"app\""
type app_aggregate_fields {
    count(columns: [app_select_column!], distinct: Boolean): Int!
    max: app_max_fields
    min: app_min_fields
}

"aggregate max on columns"
type app_max_fields {
    name: String
    storage_bucket: String
    version_latest: String
    version_supported: String
}

"aggregate min on columns"
type app_min_fields {
    name: String
    storage_bucket: String
    version_latest: String
    version_supported: String
}

"response of any mutation on the table \"app\""
type app_mutation_response {
    "number of rows affected by the mutation"
    affected_rows: Int!
    "data from the rows affected by the mutation"
    returning: [app!]!
}

"columns and relationships of \"file\""
type file {
    file_id: String!
    name: String!
    public: Boolean!
    signed_url: String!
    type: String!
    user_id: String
}

"aggregated selection of \"file\""
type file_aggregate {
    aggregate: file_aggregate_fields
    nodes: [file!]!
}

"aggregate fields of \"file\""
type file_aggregate_fields {
    count(columns: [file_select_column!], distinct: Boolean): Int!
    max: file_max_fields
    min: file_min_fields
}

"aggregate max on columns"
type file_max_fields {
    file_id: String
    name: String
    signed_url: String
    type: String
    user_id: String
}

"aggregate min on columns"
type file_min_fields {
    file_id: String
    name: String
    signed_url: String
    type: String
    user_id: String
}

"response of any mutation on the table \"file\""
type file_mutation_response {
    "number of rows affected by the mutation"
    affected_rows: Int!
    "data from the rows affected by the mutation"
    returning: [file!]!
}

"mutation root"
type mutation_root {
    "/action_mutation_pong/"
    action_mutation_pong(action_mutation_pong_input: ActionMutationPongInput): ActionMutationPongOutput
    "/action_upload_file/"
    action_upload_file(action_upload_file_input: ActionUploadFileInput): uuid!
    "delete data from the table: \"ENUM_ROLE\""
    delete_ENUM_ROLE(
        "filter the rows which have to be deleted"
        where: ENUM_ROLE_bool_exp!
    ): ENUM_ROLE_mutation_response
    "delete single row from the table: \"ENUM_ROLE\""
    delete_ENUM_ROLE_by_pk(value: String!): ENUM_ROLE
    "delete data from the table: \"app\""
    delete_app(
        "filter the rows which have to be deleted"
        where: app_bool_exp!
    ): app_mutation_response
    "delete single row from the table: \"app\""
    delete_app_by_pk(name: String!): app
    "delete data from the table: \"file\""
    delete_file(
        "filter the rows which have to be deleted"
        where: file_bool_exp!
    ): file_mutation_response
    "delete single row from the table: \"file\""
    delete_file_by_pk(file_id: String!): file
    "delete data from the table: \"public_user\""
    delete_public_user(
        "filter the rows which have to be deleted"
        where: public_user_bool_exp!
    ): public_user_mutation_response
    "delete single row from the table: \"public_user\""
    delete_public_user_by_pk(user_id: String!): public_user
    "delete data from the table: \"user\""
    delete_user(
        "filter the rows which have to be deleted"
        where: user_bool_exp!
    ): user_mutation_response
    "delete single row from the table: \"user\""
    delete_user_by_pk(user_id: String!): user
    "insert data into the table: \"ENUM_ROLE\""
    insert_ENUM_ROLE(
        "the rows to be inserted"
        objects: [ENUM_ROLE_insert_input!]!,
        "upsert condition"
        on_conflict: ENUM_ROLE_on_conflict
    ): ENUM_ROLE_mutation_response
    "insert a single row into the table: \"ENUM_ROLE\""
    insert_ENUM_ROLE_one(
        "the row to be inserted"
        object: ENUM_ROLE_insert_input!,
        "upsert condition"
        on_conflict: ENUM_ROLE_on_conflict
    ): ENUM_ROLE
    "insert data into the table: \"app\""
    insert_app(
        "the rows to be inserted"
        objects: [app_insert_input!]!,
        "upsert condition"
        on_conflict: app_on_conflict
    ): app_mutation_response
    "insert a single row into the table: \"app\""
    insert_app_one(
        "the row to be inserted"
        object: app_insert_input!,
        "upsert condition"
        on_conflict: app_on_conflict
    ): app
    "insert data into the table: \"file\""
    insert_file(
        "the rows to be inserted"
        objects: [file_insert_input!]!,
        "upsert condition"
        on_conflict: file_on_conflict
    ): file_mutation_response
    "insert a single row into the table: \"file\""
    insert_file_one(
        "the row to be inserted"
        object: file_insert_input!,
        "upsert condition"
        on_conflict: file_on_conflict
    ): file
    "insert data into the table: \"public_user\""
    insert_public_user(
        "the rows to be inserted"
        objects: [public_user_insert_input!]!,
        "upsert condition"
        on_conflict: public_user_on_conflict
    ): public_user_mutation_response
    "insert a single row into the table: \"public_user\""
    insert_public_user_one(
        "the row to be inserted"
        object: public_user_insert_input!,
        "upsert condition"
        on_conflict: public_user_on_conflict
    ): public_user
    "insert data into the table: \"user\""
    insert_user(
        "the rows to be inserted"
        objects: [user_insert_input!]!,
        "upsert condition"
        on_conflict: user_on_conflict
    ): user_mutation_response
    "insert a single row into the table: \"user\""
    insert_user_one(
        "the row to be inserted"
        object: user_insert_input!,
        "upsert condition"
        on_conflict: user_on_conflict
    ): user
    "update data of the table: \"ENUM_ROLE\""
    update_ENUM_ROLE(
        "sets the columns of the filtered rows to the given values"
        _set: ENUM_ROLE_set_input,
        "filter the rows which have to be updated"
        where: ENUM_ROLE_bool_exp!
    ): ENUM_ROLE_mutation_response
    "update single row of the table: \"ENUM_ROLE\""
    update_ENUM_ROLE_by_pk(
        "sets the columns of the filtered rows to the given values"
        _set: ENUM_ROLE_set_input,
        pk_columns: ENUM_ROLE_pk_columns_input!
    ): ENUM_ROLE
    "update multiples rows of table: \"ENUM_ROLE\""
    update_ENUM_ROLE_many(
        "updates to execute, in order"
        updates: [ENUM_ROLE_updates!]!
    ): [ENUM_ROLE_mutation_response]
    "update data of the table: \"app\""
    update_app(
        "sets the columns of the filtered rows to the given values"
        _set: app_set_input,
        "filter the rows which have to be updated"
        where: app_bool_exp!
    ): app_mutation_response
    "update single row of the table: \"app\""
    update_app_by_pk(
        "sets the columns of the filtered rows to the given values"
        _set: app_set_input,
        pk_columns: app_pk_columns_input!
    ): app
    "update multiples rows of table: \"app\""
    update_app_many(
        "updates to execute, in order"
        updates: [app_updates!]!
    ): [app_mutation_response]
    "update data of the table: \"file\""
    update_file(
        "sets the columns of the filtered rows to the given values"
        _set: file_set_input,
        "filter the rows which have to be updated"
        where: file_bool_exp!
    ): file_mutation_response
    "update single row of the table: \"file\""
    update_file_by_pk(
        "sets the columns of the filtered rows to the given values"
        _set: file_set_input,
        pk_columns: file_pk_columns_input!
    ): file
    "update multiples rows of table: \"file\""
    update_file_many(
        "updates to execute, in order"
        updates: [file_updates!]!
    ): [file_mutation_response]
    "update data of the table: \"public_user\""
    update_public_user(
        "increments the numeric columns with given value of the filtered values"
        _inc: public_user_inc_input,
        "sets the columns of the filtered rows to the given values"
        _set: public_user_set_input,
        "filter the rows which have to be updated"
        where: public_user_bool_exp!
    ): public_user_mutation_response
    "update single row of the table: \"public_user\""
    update_public_user_by_pk(
        "increments the numeric columns with given value of the filtered values"
        _inc: public_user_inc_input,
        "sets the columns of the filtered rows to the given values"
        _set: public_user_set_input,
        pk_columns: public_user_pk_columns_input!
    ): public_user
    "update multiples rows of table: \"public_user\""
    update_public_user_many(
        "updates to execute, in order"
        updates: [public_user_updates!]!
    ): [public_user_mutation_response]
    "update data of the table: \"user\""
    update_user(
        "sets the columns of the filtered rows to the given values"
        _set: user_set_input,
        "filter the rows which have to be updated"
        where: user_bool_exp!
    ): user_mutation_response
    "update single row of the table: \"user\""
    update_user_by_pk(
        "sets the columns of the filtered rows to the given values"
        _set: user_set_input,
        pk_columns: user_pk_columns_input!
    ): user
    "update multiples rows of table: \"user\""
    update_user_many(
        "updates to execute, in order"
        updates: [user_updates!]!
    ): [user_mutation_response]
}

"columns and relationships of \"public_user\""
type public_user {
    message: String!
    number: Int!
    user_id: String!
}

"aggregated selection of \"public_user\""
type public_user_aggregate {
    aggregate: public_user_aggregate_fields
    nodes: [public_user!]!
}

"aggregate fields of \"public_user\""
type public_user_aggregate_fields {
    avg: public_user_avg_fields
    count(columns: [public_user_select_column!], distinct: Boolean): Int!
    max: public_user_max_fields
    min: public_user_min_fields
    stddev: public_user_stddev_fields
    stddev_pop: public_user_stddev_pop_fields
    stddev_samp: public_user_stddev_samp_fields
    sum: public_user_sum_fields
    var_pop: public_user_var_pop_fields
    var_samp: public_user_var_samp_fields
    variance: public_user_variance_fields
}

"aggregate avg on columns"
type public_user_avg_fields {
    number: Float
}

"aggregate max on columns"
type public_user_max_fields {
    message: String
    number: Int
    user_id: String
}

"aggregate min on columns"
type public_user_min_fields {
    message: String
    number: Int
    user_id: String
}

"response of any mutation on the table \"public_user\""
type public_user_mutation_response {
    "number of rows affected by the mutation"
    affected_rows: Int!
    "data from the rows affected by the mutation"
    returning: [public_user!]!
}

"aggregate stddev on columns"
type public_user_stddev_fields {
    number: Float
}

"aggregate stddev_pop on columns"
type public_user_stddev_pop_fields {
    number: Float
}

"aggregate stddev_samp on columns"
type public_user_stddev_samp_fields {
    number: Float
}

"aggregate sum on columns"
type public_user_sum_fields {
    number: Int
}

"aggregate var_pop on columns"
type public_user_var_pop_fields {
    number: Float
}

"aggregate var_samp on columns"
type public_user_var_samp_fields {
    number: Float
}

"aggregate variance on columns"
type public_user_variance_fields {
    number: Float
}

type query_root {
    "fetch data from the table: \"ENUM_ROLE\""
    ENUM_ROLE(
        "distinct select on columns"
        distinct_on: [ENUM_ROLE_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [ENUM_ROLE_order_by!],
        "filter the rows returned"
        where: ENUM_ROLE_bool_exp
    ): [ENUM_ROLE!]!
    "fetch aggregated fields from the table: \"ENUM_ROLE\""
    ENUM_ROLE_aggregate(
        "distinct select on columns"
        distinct_on: [ENUM_ROLE_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [ENUM_ROLE_order_by!],
        "filter the rows returned"
        where: ENUM_ROLE_bool_exp
    ): ENUM_ROLE_aggregate!
    "fetch data from the table: \"ENUM_ROLE\" using primary key columns"
    ENUM_ROLE_by_pk(value: String!): ENUM_ROLE
    "/action_query_ping/"
    action_query_ping(action_query_ping_input: ActionQueryPingInput): ActionQueryPingOutput
    "/action_upload_file/"
    action_upload_file(
        "the unique id of an action"
        id: uuid!
    ): action_upload_file
    "fetch data from the table: \"app\""
    app(
        "distinct select on columns"
        distinct_on: [app_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [app_order_by!],
        "filter the rows returned"
        where: app_bool_exp
    ): [app!]!
    "fetch aggregated fields from the table: \"app\""
    app_aggregate(
        "distinct select on columns"
        distinct_on: [app_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [app_order_by!],
        "filter the rows returned"
        where: app_bool_exp
    ): app_aggregate!
    "fetch data from the table: \"app\" using primary key columns"
    app_by_pk(name: String!): app
    "fetch data from the table: \"file\""
    file(
        "distinct select on columns"
        distinct_on: [file_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [file_order_by!],
        "filter the rows returned"
        where: file_bool_exp
    ): [file!]!
    "fetch aggregated fields from the table: \"file\""
    file_aggregate(
        "distinct select on columns"
        distinct_on: [file_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [file_order_by!],
        "filter the rows returned"
        where: file_bool_exp
    ): file_aggregate!
    "fetch data from the table: \"file\" using primary key columns"
    file_by_pk(file_id: String!): file
    "fetch data from the table: \"public_user\""
    public_user(
        "distinct select on columns"
        distinct_on: [public_user_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [public_user_order_by!],
        "filter the rows returned"
        where: public_user_bool_exp
    ): [public_user!]!
    "fetch aggregated fields from the table: \"public_user\""
    public_user_aggregate(
        "distinct select on columns"
        distinct_on: [public_user_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [public_user_order_by!],
        "filter the rows returned"
        where: public_user_bool_exp
    ): public_user_aggregate!
    "fetch data from the table: \"public_user\" using primary key columns"
    public_user_by_pk(user_id: String!): public_user
    "fetch data from the table: \"user\""
    user(
        "distinct select on columns"
        distinct_on: [user_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [user_order_by!],
        "filter the rows returned"
        where: user_bool_exp
    ): [user!]!
    "fetch aggregated fields from the table: \"user\""
    user_aggregate(
        "distinct select on columns"
        distinct_on: [user_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [user_order_by!],
        "filter the rows returned"
        where: user_bool_exp
    ): user_aggregate!
    "fetch data from the table: \"user\" using primary key columns"
    user_by_pk(user_id: String!): user
}

type subscription_root {
    "fetch data from the table: \"ENUM_ROLE\""
    ENUM_ROLE(
        "distinct select on columns"
        distinct_on: [ENUM_ROLE_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [ENUM_ROLE_order_by!],
        "filter the rows returned"
        where: ENUM_ROLE_bool_exp
    ): [ENUM_ROLE!]!
    "fetch aggregated fields from the table: \"ENUM_ROLE\""
    ENUM_ROLE_aggregate(
        "distinct select on columns"
        distinct_on: [ENUM_ROLE_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [ENUM_ROLE_order_by!],
        "filter the rows returned"
        where: ENUM_ROLE_bool_exp
    ): ENUM_ROLE_aggregate!
    "fetch data from the table: \"ENUM_ROLE\" using primary key columns"
    ENUM_ROLE_by_pk(value: String!): ENUM_ROLE
    "fetch data from the table in a streaming manner: \"ENUM_ROLE\""
    ENUM_ROLE_stream(
        "maximum number of rows returned in a single batch"
        batch_size: Int!,
        "cursor to stream the results returned by the query"
        cursor: [ENUM_ROLE_stream_cursor_input]!,
        "filter the rows returned"
        where: ENUM_ROLE_bool_exp
    ): [ENUM_ROLE!]!
    "/action_upload_file/"
    action_upload_file(
        "the unique id of an action"
        id: uuid!
    ): action_upload_file
    "fetch data from the table: \"app\""
    app(
        "distinct select on columns"
        distinct_on: [app_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [app_order_by!],
        "filter the rows returned"
        where: app_bool_exp
    ): [app!]!
    "fetch aggregated fields from the table: \"app\""
    app_aggregate(
        "distinct select on columns"
        distinct_on: [app_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [app_order_by!],
        "filter the rows returned"
        where: app_bool_exp
    ): app_aggregate!
    "fetch data from the table: \"app\" using primary key columns"
    app_by_pk(name: String!): app
    "fetch data from the table in a streaming manner: \"app\""
    app_stream(
        "maximum number of rows returned in a single batch"
        batch_size: Int!,
        "cursor to stream the results returned by the query"
        cursor: [app_stream_cursor_input]!,
        "filter the rows returned"
        where: app_bool_exp
    ): [app!]!
    "fetch data from the table: \"file\""
    file(
        "distinct select on columns"
        distinct_on: [file_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [file_order_by!],
        "filter the rows returned"
        where: file_bool_exp
    ): [file!]!
    "fetch aggregated fields from the table: \"file\""
    file_aggregate(
        "distinct select on columns"
        distinct_on: [file_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [file_order_by!],
        "filter the rows returned"
        where: file_bool_exp
    ): file_aggregate!
    "fetch data from the table: \"file\" using primary key columns"
    file_by_pk(file_id: String!): file
    "fetch data from the table in a streaming manner: \"file\""
    file_stream(
        "maximum number of rows returned in a single batch"
        batch_size: Int!,
        "cursor to stream the results returned by the query"
        cursor: [file_stream_cursor_input]!,
        "filter the rows returned"
        where: file_bool_exp
    ): [file!]!
    "fetch data from the table: \"public_user\""
    public_user(
        "distinct select on columns"
        distinct_on: [public_user_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [public_user_order_by!],
        "filter the rows returned"
        where: public_user_bool_exp
    ): [public_user!]!
    "fetch aggregated fields from the table: \"public_user\""
    public_user_aggregate(
        "distinct select on columns"
        distinct_on: [public_user_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [public_user_order_by!],
        "filter the rows returned"
        where: public_user_bool_exp
    ): public_user_aggregate!
    "fetch data from the table: \"public_user\" using primary key columns"
    public_user_by_pk(user_id: String!): public_user
    "fetch data from the table in a streaming manner: \"public_user\""
    public_user_stream(
        "maximum number of rows returned in a single batch"
        batch_size: Int!,
        "cursor to stream the results returned by the query"
        cursor: [public_user_stream_cursor_input]!,
        "filter the rows returned"
        where: public_user_bool_exp
    ): [public_user!]!
    "fetch data from the table: \"user\""
    user(
        "distinct select on columns"
        distinct_on: [user_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [user_order_by!],
        "filter the rows returned"
        where: user_bool_exp
    ): [user!]!
    "fetch aggregated fields from the table: \"user\""
    user_aggregate(
        "distinct select on columns"
        distinct_on: [user_select_column!],
        "limit the number of rows returned"
        limit: Int,
        "skip the first n rows. Use only with order_by"
        offset: Int,
        "sort the rows by one or more columns"
        order_by: [user_order_by!],
        "filter the rows returned"
        where: user_bool_exp
    ): user_aggregate!
    "fetch data from the table: \"user\" using primary key columns"
    user_by_pk(user_id: String!): user
    "fetch data from the table in a streaming manner: \"user\""
    user_stream(
        "maximum number of rows returned in a single batch"
        batch_size: Int!,
        "cursor to stream the results returned by the query"
        cursor: [user_stream_cursor_input]!,
        "filter the rows returned"
        where: user_bool_exp
    ): [user!]!
}

"columns and relationships of \"user\""
type user {
    created_at: timestamptz
    role: ENUM_ROLE_enum!
    updated_at: timestamptz
    user_id: String!
    user_phone: String!
}

"aggregated selection of \"user\""
type user_aggregate {
    aggregate: user_aggregate_fields
    nodes: [user!]!
}

"aggregate fields of \"user\""
type user_aggregate_fields {
    count(columns: [user_select_column!], distinct: Boolean): Int!
    max: user_max_fields
    min: user_min_fields
}

"aggregate max on columns"
type user_max_fields {
    created_at: timestamptz
    updated_at: timestamptz
    user_id: String
    user_phone: String
}

"aggregate min on columns"
type user_min_fields {
    created_at: timestamptz
    updated_at: timestamptz
    user_id: String
    user_phone: String
}

"response of any mutation on the table \"user\""
type user_mutation_response {
    "number of rows affected by the mutation"
    affected_rows: Int!
    "data from the rows affected by the mutation"
    returning: [user!]!
}

"unique or primary key constraints on table \"ENUM_ROLE\""
enum ENUM_ROLE_constraint {
    "unique or primary key constraint on columns \"value\""
    ENUM_ROLE_pkey
}

enum ENUM_ROLE_enum {
    admin
    user
}

"select columns of table \"ENUM_ROLE\""
enum ENUM_ROLE_select_column {
    "column name"
    comment
    "column name"
    value
}

"update columns of table \"ENUM_ROLE\""
enum ENUM_ROLE_update_column {
    "column name"
    comment
    "column name"
    value
}

"unique or primary key constraints on table \"app\""
enum app_constraint {
    "unique or primary key constraint on columns \"name\""
    app_pkey
}

"select columns of table \"app\""
enum app_select_column {
    "column name"
    name
    "column name"
    storage_bucket
    "column name"
    version_latest
    "column name"
    version_supported
}

"update columns of table \"app\""
enum app_update_column {
    "column name"
    name
    "column name"
    storage_bucket
    "column name"
    version_latest
    "column name"
    version_supported
}

"ordering argument of a cursor"
enum cursor_ordering {
    "ascending ordering of the cursor"
    ASC
    "descending ordering of the cursor"
    DESC
}

"unique or primary key constraints on table \"file\""
enum file_constraint {
    "unique or primary key constraint on columns \"file_id\""
    file_pkey
}

"select columns of table \"file\""
enum file_select_column {
    "column name"
    file_id
    "column name"
    name
    "column name"
    public
    "column name"
    signed_url
    "column name"
    type
    "column name"
    user_id
}

"update columns of table \"file\""
enum file_update_column {
    "column name"
    file_id
    "column name"
    name
    "column name"
    public
    "column name"
    signed_url
    "column name"
    type
    "column name"
    user_id
}

"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
}

"unique or primary key constraints on table \"public_user\""
enum public_user_constraint {
    "unique or primary key constraint on columns \"user_id\""
    public_user_pkey
}

"select columns of table \"public_user\""
enum public_user_select_column {
    "column name"
    message
    "column name"
    number
    "column name"
    user_id
}

"update columns of table \"public_user\""
enum public_user_update_column {
    "column name"
    message
    "column name"
    number
    "column name"
    user_id
}

"unique or primary key constraints on table \"user\""
enum user_constraint {
    "unique or primary key constraint on columns \"user_id\""
    user_pkey
    "unique or primary key constraint on columns \"user_phone\""
    user_user_phone_key
}

"select columns of table \"user\""
enum user_select_column {
    "column name"
    created_at
    "column name"
    role
    "column name"
    updated_at
    "column name"
    user_id
    "column name"
    user_phone
}

"update columns of table \"user\""
enum user_update_column {
    "column name"
    created_at
    "column name"
    role
    "column name"
    updated_at
    "column name"
    user_id
    "column name"
    user_phone
}

scalar json

scalar timestamptz

scalar uuid

input ActionMutationPongInput {
    message: String!
    number: Int!
}

input ActionQueryPingInput {
    message: String
    number: Int
}

input ActionUploadFileInput {
    file_data: String!
    file_name: String!
    file_type: String!
}

"Boolean expression to compare columns of type \"Boolean\". All fields are combined with logical 'AND'."
input Boolean_comparison_exp {
    _eq: Boolean
    _gt: Boolean
    _gte: Boolean
    _in: [Boolean!]
    _is_null: Boolean
    _lt: Boolean
    _lte: Boolean
    _neq: Boolean
    _nin: [Boolean!]
}

"Boolean expression to filter rows from the table \"ENUM_ROLE\". All fields are combined with a logical 'AND'."
input ENUM_ROLE_bool_exp {
    _and: [ENUM_ROLE_bool_exp!]
    _not: ENUM_ROLE_bool_exp
    _or: [ENUM_ROLE_bool_exp!]
    comment: String_comparison_exp
    value: String_comparison_exp
}

"Boolean expression to compare columns of type \"ENUM_ROLE_enum\". All fields are combined with logical 'AND'."
input ENUM_ROLE_enum_comparison_exp {
    _eq: ENUM_ROLE_enum
    _in: [ENUM_ROLE_enum!]
    _is_null: Boolean
    _neq: ENUM_ROLE_enum
    _nin: [ENUM_ROLE_enum!]
}

"input type for inserting data into table \"ENUM_ROLE\""
input ENUM_ROLE_insert_input {
    comment: String
    value: String
}

"on_conflict condition type for table \"ENUM_ROLE\""
input ENUM_ROLE_on_conflict {
    constraint: ENUM_ROLE_constraint!
    update_columns: [ENUM_ROLE_update_column!]! = []
    where: ENUM_ROLE_bool_exp
}

"Ordering options when selecting data from \"ENUM_ROLE\"."
input ENUM_ROLE_order_by {
    comment: order_by
    value: order_by
}

"primary key columns input for table: ENUM_ROLE"
input ENUM_ROLE_pk_columns_input {
    value: String!
}

"input type for updating data in table \"ENUM_ROLE\""
input ENUM_ROLE_set_input {
    comment: String
    value: String
}

"Streaming cursor of the table \"ENUM_ROLE\""
input ENUM_ROLE_stream_cursor_input {
    "Stream column input with initial value"
    initial_value: ENUM_ROLE_stream_cursor_value_input!
    "cursor ordering"
    ordering: cursor_ordering
}

"Initial value of the column from where the streaming should start"
input ENUM_ROLE_stream_cursor_value_input {
    comment: String
    value: String
}

input ENUM_ROLE_updates {
    "sets the columns of the filtered rows to the given values"
    _set: ENUM_ROLE_set_input
    "filter the rows which have to be updated"
    where: ENUM_ROLE_bool_exp!
}

"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!]
}

"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
}

"Boolean expression to filter rows from the table \"app\". All fields are combined with a logical 'AND'."
input app_bool_exp {
    _and: [app_bool_exp!]
    _not: app_bool_exp
    _or: [app_bool_exp!]
    name: String_comparison_exp
    storage_bucket: String_comparison_exp
    version_latest: String_comparison_exp
    version_supported: String_comparison_exp
}

"input type for inserting data into table \"app\""
input app_insert_input {
    name: String
    storage_bucket: String
    version_latest: String
    version_supported: String
}

"on_conflict condition type for table \"app\""
input app_on_conflict {
    constraint: app_constraint!
    update_columns: [app_update_column!]! = []
    where: app_bool_exp
}

"Ordering options when selecting data from \"app\"."
input app_order_by {
    name: order_by
    storage_bucket: order_by
    version_latest: order_by
    version_supported: order_by
}

"primary key columns input for table: app"
input app_pk_columns_input {
    name: String!
}

"input type for updating data in table \"app\""
input app_set_input {
    name: String
    storage_bucket: String
    version_latest: String
    version_supported: String
}

"Streaming cursor of the table \"app\""
input app_stream_cursor_input {
    "Stream column input with initial value"
    initial_value: app_stream_cursor_value_input!
    "cursor ordering"
    ordering: cursor_ordering
}

"Initial value of the column from where the streaming should start"
input app_stream_cursor_value_input {
    name: String
    storage_bucket: String
    version_latest: String
    version_supported: String
}

input app_updates {
    "sets the columns of the filtered rows to the given values"
    _set: app_set_input
    "filter the rows which have to be updated"
    where: app_bool_exp!
}

"Boolean expression to filter rows from the table \"file\". All fields are combined with a logical 'AND'."
input file_bool_exp {
    _and: [file_bool_exp!]
    _not: file_bool_exp
    _or: [file_bool_exp!]
    file_id: String_comparison_exp
    name: String_comparison_exp
    public: Boolean_comparison_exp
    signed_url: String_comparison_exp
    type: String_comparison_exp
    user_id: String_comparison_exp
}

"input type for inserting data into table \"file\""
input file_insert_input {
    file_id: String
    name: String
    public: Boolean
    signed_url: String
    type: String
    user_id: String
}

"on_conflict condition type for table \"file\""
input file_on_conflict {
    constraint: file_constraint!
    update_columns: [file_update_column!]! = []
    where: file_bool_exp
}

"Ordering options when selecting data from \"file\"."
input file_order_by {
    file_id: order_by
    name: order_by
    public: order_by
    signed_url: order_by
    type: order_by
    user_id: order_by
}

"primary key columns input for table: file"
input file_pk_columns_input {
    file_id: String!
}

"input type for updating data in table \"file\""
input file_set_input {
    file_id: String
    name: String
    public: Boolean
    signed_url: String
    type: String
    user_id: String
}

"Streaming cursor of the table \"file\""
input file_stream_cursor_input {
    "Stream column input with initial value"
    initial_value: file_stream_cursor_value_input!
    "cursor ordering"
    ordering: cursor_ordering
}

"Initial value of the column from where the streaming should start"
input file_stream_cursor_value_input {
    file_id: String
    name: String
    public: Boolean
    signed_url: String
    type: String
    user_id: String
}

input file_updates {
    "sets the columns of the filtered rows to the given values"
    _set: file_set_input
    "filter the rows which have to be updated"
    where: file_bool_exp!
}

"Boolean expression to filter rows from the table \"public_user\". All fields are combined with a logical 'AND'."
input public_user_bool_exp {
    _and: [public_user_bool_exp!]
    _not: public_user_bool_exp
    _or: [public_user_bool_exp!]
    message: String_comparison_exp
    number: Int_comparison_exp
    user_id: String_comparison_exp
}

"input type for incrementing numeric columns in table \"public_user\""
input public_user_inc_input {
    number: Int
}

"input type for inserting data into table \"public_user\""
input public_user_insert_input {
    message: String
    number: Int
    user_id: String
}

"on_conflict condition type for table \"public_user\""
input public_user_on_conflict {
    constraint: public_user_constraint!
    update_columns: [public_user_update_column!]! = []
    where: public_user_bool_exp
}

"Ordering options when selecting data from \"public_user\"."
input public_user_order_by {
    message: order_by
    number: order_by
    user_id: order_by
}

"primary key columns input for table: public_user"
input public_user_pk_columns_input {
    user_id: String!
}

"input type for updating data in table \"public_user\""
input public_user_set_input {
    message: String
    number: Int
    user_id: String
}

"Streaming cursor of the table \"public_user\""
input public_user_stream_cursor_input {
    "Stream column input with initial value"
    initial_value: public_user_stream_cursor_value_input!
    "cursor ordering"
    ordering: cursor_ordering
}

"Initial value of the column from where the streaming should start"
input public_user_stream_cursor_value_input {
    message: String
    number: Int
    user_id: String
}

input public_user_updates {
    "increments the numeric columns with given value of the filtered values"
    _inc: public_user_inc_input
    "sets the columns of the filtered rows to the given values"
    _set: public_user_set_input
    "filter the rows which have to be updated"
    where: public_user_bool_exp!
}

"Boolean expression to compare columns of type \"timestamptz\". All fields are combined with logical 'AND'."
input timestamptz_comparison_exp {
    _eq: timestamptz
    _gt: timestamptz
    _gte: timestamptz
    _in: [timestamptz!]
    _is_null: Boolean
    _lt: timestamptz
    _lte: timestamptz
    _neq: timestamptz
    _nin: [timestamptz!]
}

"Boolean expression to filter rows from the table \"user\". All fields are combined with a logical 'AND'."
input user_bool_exp {
    _and: [user_bool_exp!]
    _not: user_bool_exp
    _or: [user_bool_exp!]
    created_at: timestamptz_comparison_exp
    role: ENUM_ROLE_enum_comparison_exp
    updated_at: timestamptz_comparison_exp
    user_id: String_comparison_exp
    user_phone: String_comparison_exp
}

"input type for inserting data into table \"user\""
input user_insert_input {
    created_at: timestamptz
    role: ENUM_ROLE_enum
    updated_at: timestamptz
    user_id: String
    user_phone: String
}

"on_conflict condition type for table \"user\""
input user_on_conflict {
    constraint: user_constraint!
    update_columns: [user_update_column!]! = []
    where: user_bool_exp
}

"Ordering options when selecting data from \"user\"."
input user_order_by {
    created_at: order_by
    role: order_by
    updated_at: order_by
    user_id: order_by
    user_phone: order_by
}

"primary key columns input for table: user"
input user_pk_columns_input {
    user_id: String!
}

"input type for updating data in table \"user\""
input user_set_input {
    created_at: timestamptz
    role: ENUM_ROLE_enum
    updated_at: timestamptz
    user_id: String
    user_phone: String
}

"Streaming cursor of the table \"user\""
input user_stream_cursor_input {
    "Stream column input with initial value"
    initial_value: user_stream_cursor_value_input!
    "cursor ordering"
    ordering: cursor_ordering
}

"Initial value of the column from where the streaming should start"
input user_stream_cursor_value_input {
    created_at: timestamptz
    role: ENUM_ROLE_enum
    updated_at: timestamptz
    user_id: String
    user_phone: String
}

input user_updates {
    "sets the columns of the filtered rows to the given values"
    _set: user_set_input
    "filter the rows which have to be updated"
    where: user_bool_exp!
}
