/* eslint-disable */
import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core'
export type Maybe<T> = T | null
export type InputMaybe<T> = Maybe<T>
export type Exact<T extends { [key: string]: unknown }> = {
  [K in keyof T]: T[K]
}
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]?: Maybe<T[SubKey]>
}
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]: Maybe<T[SubKey]>
}
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string
  String: string
  Boolean: boolean
  Int: number
  Float: number
  /**
   * A date-time string at UTC, such as 2007-12-03T10:15:30Z, is compliant with the date-time format outlined in section 5.6 of the RFC 3339
   * profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar.
   *
   * This scalar is a description of an exact instant on the timeline such as the instant that a user account was created.
   *
   * # Input Coercion
   *
   * When expected as an input type, only RFC 3339 compliant date-time strings are accepted. All other input values raise a query error indicating an incorrect type.
   *
   * # Result Coercion
   *
   * Where an RFC 3339 compliant date-time string has a time-zone other than UTC, it is shifted to UTC.
   * For example, the date-time string 2016-01-01T14:10:20+01:00 is shifted to 2016-01-01T13:10:20Z.
   */
  DateTime: any
}

export type Comment = {
  __typename?: 'Comment'
  /** when the model was created */
  createdAt: Scalars['DateTime']
  id: Scalars['ID']
  message: Scalars['String']
  post?: Maybe<Post>
  /** when the model was updated */
  updatedAt: Scalars['DateTime']
}

export type CommentByInput = {
  id?: InputMaybe<Scalars['ID']>
}

/** Input to create a new CommentCommentRelatePostPost */
export type CommentCommentRelatePostPostCreateInput = {
  slug: Scalars['String']
  title: Scalars['String']
}

/** Input to create a new CommentCommentRelatePostPost relation */
export type CommentCommentRelatePostPostCreateRelationInput = {
  create?: InputMaybe<CommentCommentRelatePostPostCreateInput>
  link?: InputMaybe<Scalars['ID']>
}

/** Input to update a CommentCommentRelatePostPost relation */
export type CommentCommentRelatePostPostUpdateRelationInput = {
  create?: InputMaybe<CommentCommentRelatePostPostCreateInput>
  link?: InputMaybe<Scalars['ID']>
  unlink?: InputMaybe<Scalars['ID']>
}

export type CommentConnection = {
  __typename?: 'CommentConnection'
  edges?: Maybe<Array<Maybe<CommentEdge>>>
  /** Information to aid in pagination */
  pageInfo: PageInfo
}

/** Input to create a new Comment */
export type CommentCreateInput = {
  message: Scalars['String']
  post?: InputMaybe<CommentCommentRelatePostPostCreateRelationInput>
}

export type CommentCreatePayload = {
  __typename?: 'CommentCreatePayload'
  comment?: Maybe<Comment>
}

export type CommentDeletePayload = {
  __typename?: 'CommentDeletePayload'
  deletedId: Scalars['ID']
}

export type CommentEdge = {
  __typename?: 'CommentEdge'
  cursor: Scalars['String']
  node: Comment
}

/** Input to create a new Comment */
export type CommentUpdateInput = {
  message?: InputMaybe<Scalars['String']>
  post?: InputMaybe<CommentCommentRelatePostPostUpdateRelationInput>
}

export type CommentUpdatePayload = {
  __typename?: 'CommentUpdatePayload'
  comment?: Maybe<Comment>
}

export type Mutation = {
  __typename?: 'Mutation'
  /** Create a Comment */
  commentCreate?: Maybe<CommentCreatePayload>
  /** Delete a Comment by ID or unique field */
  commentDelete?: Maybe<CommentDeletePayload>
  /** Update a Comment */
  commentUpdate?: Maybe<CommentUpdatePayload>
  /** Create a Post */
  postCreate?: Maybe<PostCreatePayload>
  /** Delete a Post by ID or unique field */
  postDelete?: Maybe<PostDeletePayload>
  /** Update a Post */
  postUpdate?: Maybe<PostUpdatePayload>
}

export type MutationCommentCreateArgs = {
  input: CommentCreateInput
}

export type MutationCommentDeleteArgs = {
  by: CommentByInput
}

export type MutationCommentUpdateArgs = {
  by: CommentByInput
  input: CommentUpdateInput
}

export type MutationPostCreateArgs = {
  input: PostCreateInput
}

export type MutationPostDeleteArgs = {
  by: PostByInput
}

export type MutationPostUpdateArgs = {
  by: PostByInput
  input: PostUpdateInput
}

export type PageInfo = {
  __typename?: 'PageInfo'
  endCursor?: Maybe<Scalars['String']>
  hasNextPage: Scalars['Boolean']
  hasPreviousPage: Scalars['Boolean']
  startCursor?: Maybe<Scalars['String']>
}

export type Post = {
  __typename?: 'Post'
  comments?: Maybe<CommentConnection>
  /** when the model was created */
  createdAt: Scalars['DateTime']
  id: Scalars['ID']
  slug: Scalars['String']
  title: Scalars['String']
  /** when the model was updated */
  updatedAt: Scalars['DateTime']
}

export type PostCommentsArgs = {
  after?: InputMaybe<Scalars['String']>
  before?: InputMaybe<Scalars['String']>
  first?: InputMaybe<Scalars['Int']>
  last?: InputMaybe<Scalars['Int']>
}

export type PostByInput = {
  id?: InputMaybe<Scalars['ID']>
  slug?: InputMaybe<Scalars['String']>
}

/** Input to create a new PostCommentRelatePostComment */
export type PostCommentRelatePostCommentCreateInput = {
  message: Scalars['String']
}

/** Input to create a new PostCommentRelatePostComment relation */
export type PostCommentRelatePostCommentCreateRelationInput = {
  create?: InputMaybe<PostCommentRelatePostCommentCreateInput>
  link?: InputMaybe<Scalars['ID']>
}

/** Input to update a PostCommentRelatePostComment relation */
export type PostCommentRelatePostCommentUpdateRelationInput = {
  create?: InputMaybe<PostCommentRelatePostCommentCreateInput>
  link?: InputMaybe<Scalars['ID']>
  unlink?: InputMaybe<Scalars['ID']>
}

export type PostConnection = {
  __typename?: 'PostConnection'
  edges?: Maybe<Array<Maybe<PostEdge>>>
  /** Information to aid in pagination */
  pageInfo: PageInfo
}

/** Input to create a new Post */
export type PostCreateInput = {
  comments?: InputMaybe<
    Array<InputMaybe<PostCommentRelatePostCommentCreateRelationInput>>
  >
  slug: Scalars['String']
  title: Scalars['String']
}

export type PostCreatePayload = {
  __typename?: 'PostCreatePayload'
  post?: Maybe<Post>
}

export type PostDeletePayload = {
  __typename?: 'PostDeletePayload'
  deletedId: Scalars['ID']
}

export type PostEdge = {
  __typename?: 'PostEdge'
  cursor: Scalars['String']
  node: Post
}

/** Input to create a new Post */
export type PostUpdateInput = {
  comments?: InputMaybe<
    Array<InputMaybe<PostCommentRelatePostCommentUpdateRelationInput>>
  >
  slug?: InputMaybe<Scalars['String']>
  title?: InputMaybe<Scalars['String']>
}

export type PostUpdatePayload = {
  __typename?: 'PostUpdatePayload'
  post?: Maybe<Post>
}

export type Query = {
  __typename?: 'Query'
  /** Query a single Comment by an ID or a unique field */
  comment?: Maybe<Comment>
  /** Paginated query to fetch the whole list of `Comment`. */
  commentCollection?: Maybe<CommentConnection>
  /** Query a single Post by an ID or a unique field */
  post?: Maybe<Post>
  /** Paginated query to fetch the whole list of `Post`. */
  postCollection?: Maybe<PostConnection>
}

export type QueryCommentArgs = {
  by: CommentByInput
}

export type QueryCommentCollectionArgs = {
  after?: InputMaybe<Scalars['String']>
  before?: InputMaybe<Scalars['String']>
  first?: InputMaybe<Scalars['Int']>
  last?: InputMaybe<Scalars['Int']>
}

export type QueryPostArgs = {
  by: PostByInput
}

export type QueryPostCollectionArgs = {
  after?: InputMaybe<Scalars['String']>
  before?: InputMaybe<Scalars['String']>
  first?: InputMaybe<Scalars['Int']>
  last?: InputMaybe<Scalars['Int']>
}

export type GetAllPostsQueryVariables = Exact<{
  first: Scalars['Int']
}>

export type GetAllPostsQuery = {
  __typename?: 'Query'
  postCollection?: {
    __typename?: 'PostConnection'
    edges?: Array<{
      __typename?: 'PostEdge'
      node: { __typename?: 'Post'; id: string; title: string; slug: string }
    } | null> | null
  } | null
}

export type GetPostBySlugQueryVariables = Exact<{
  slug: Scalars['String']
}>

export type GetPostBySlugQuery = {
  __typename?: 'Query'
  post?: { __typename?: 'Post'; id: string; title: string; slug: string } | null
}

export const GetAllPostsDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'GetAllPosts' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: {
            kind: 'Variable',
            name: { kind: 'Name', value: 'first' },
          },
          type: {
            kind: 'NonNullType',
            type: { kind: 'NamedType', name: { kind: 'Name', value: 'Int' } },
          },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'postCollection' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'first' },
                value: {
                  kind: 'Variable',
                  name: { kind: 'Name', value: 'first' },
                },
              },
            ],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                {
                  kind: 'Field',
                  name: { kind: 'Name', value: 'edges' },
                  selectionSet: {
                    kind: 'SelectionSet',
                    selections: [
                      {
                        kind: 'Field',
                        name: { kind: 'Name', value: 'node' },
                        selectionSet: {
                          kind: 'SelectionSet',
                          selections: [
                            {
                              kind: 'Field',
                              name: { kind: 'Name', value: 'id' },
                            },
                            {
                              kind: 'Field',
                              name: { kind: 'Name', value: 'title' },
                            },
                            {
                              kind: 'Field',
                              name: { kind: 'Name', value: 'slug' },
                            },
                          ],
                        },
                      },
                    ],
                  },
                },
              ],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<GetAllPostsQuery, GetAllPostsQueryVariables>
export const GetPostBySlugDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'GetPostBySlug' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: { kind: 'Variable', name: { kind: 'Name', value: 'slug' } },
          type: {
            kind: 'NonNullType',
            type: {
              kind: 'NamedType',
              name: { kind: 'Name', value: 'String' },
            },
          },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'post' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'by' },
                value: {
                  kind: 'ObjectValue',
                  fields: [
                    {
                      kind: 'ObjectField',
                      name: { kind: 'Name', value: 'slug' },
                      value: {
                        kind: 'Variable',
                        name: { kind: 'Name', value: 'slug' },
                      },
                    },
                  ],
                },
              },
            ],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                { kind: 'Field', name: { kind: 'Name', value: 'id' } },
                { kind: 'Field', name: { kind: 'Name', value: 'title' } },
                { kind: 'Field', name: { kind: 'Name', value: 'slug' } },
              ],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<GetPostBySlugQuery, GetPostBySlugQueryVariables>