schema.graphql

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

schema {
    query: RootQuery
    mutation: RootMutation
}

"A Field Group registered by ACF"
interface AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"The author of a comment"
interface Commenter {
    "Avatar object for user. The avatar object can be retrieved in different sizes by specifying the size argument."
    avatar: Avatar
    "Identifies the primary key from the database."
    databaseId: Int!
    "The email address of the author of a comment."
    email: String
    "The globally unique identifier for the comment author."
    id: ID!
    "Whether the author information is considered restricted. (not fully public)"
    isRestricted: Boolean
    "The name of the author of a comment."
    name: String
    "The url of the author of a comment."
    url: String
}

"Nodes used to manage content"
interface ContentNode {
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The ID of the node in the database."
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The unique resource identifier path"
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "The template assigned to a node of content"
    template: ContentTemplate
    "The unique resource identifier path"
    uri: String
}

"The template assigned to a node of content"
interface ContentTemplate {
    "The name of the template"
    templateName: String
}

"Object that can be identified with a Database ID"
interface DatabaseIdentifier {
    "The unique identifier stored in the database"
    databaseId: Int!
}

"Asset enqueued by the CMS"
interface EnqueuedAsset {
    "@todo"
    args: Boolean
    "Dependencies needed to use this asset"
    dependencies: [EnqueuedScript]
    "Extra information needed for the script"
    extra: String
    "The handle of the enqueued asset"
    handle: String
    "The ID of the enqueued asset"
    id: ID!
    "The source of the asset"
    src: String
    "The version of the enqueued asset"
    version: String
}

"Content node with hierarchical (parent/child) relationships"
interface HierarchicalContentNode {
    "Returns ancestors of the node. Default ordered as lowest (closest to the child) to highest (closest to the root)."
    ancestors(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: HierarchicalContentNodeToContentNodeAncestorsConnectionWhereArgs
    ): HierarchicalContentNodeToContentNodeAncestorsConnection
    "Connection between the HierarchicalContentNode type and the ContentNode type"
    children(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: HierarchicalContentNodeToContentNodeChildrenConnectionWhereArgs
    ): HierarchicalContentNodeToContentNodeChildrenConnection
    "The parent of the node. The parent object can be of various types"
    parent: HierarchicalContentNodeToParentContentNodeConnectionEdge
    "Database id of the parent node"
    parentDatabaseId: Int
    "The globally unique identifier of the parent node."
    parentId: ID
}

"Term node with hierarchical (parent/child) relationships"
interface HierarchicalTermNode {
    "Database id of the parent node"
    parentDatabaseId: Int
    "The globally unique identifier of the parent node."
    parentId: ID
}

"Nodes that can be linked to as Menu Items"
interface MenuItemLinkable {
    "The unique resource identifier path"
    databaseId: Int!
    "The unique resource identifier path"
    id: ID!
    "The unique resource identifier path"
    uri: String
}

"An object with an ID"
interface Node {
    "The globally unique ID for the object"
    id: ID!
}

"A node that can have an author assigned to it"
interface NodeWithAuthor {
    "Connection between the NodeWithAuthor type and the User type"
    author: NodeWithAuthorToUserConnectionEdge
    "The database identifier of the author of the node"
    authorDatabaseId: Int
    "The globally unique identifier of the author of the node"
    authorId: ID
}

"A node that can have comments associated with it"
interface NodeWithComments {
    "The number of comments. Even though WPGraphQL denotes this field as an integer, in WordPress this field should be saved as a numeric string for compatibility."
    commentCount: Int
    "Whether the comments are open or closed for this particular post."
    commentStatus: String
}

"A node that supports the content editor"
interface NodeWithContentEditor {
    "The content of the post."
    content(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
}

"A node that can have an excerpt"
interface NodeWithExcerpt {
    "The excerpt of the post."
    excerpt(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
}

"A node that can have a featured image set"
interface NodeWithFeaturedImage {
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The unique identifier stored in the database"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "Connection between the NodeWithFeaturedImage type and the MediaItem type"
    featuredImage: NodeWithFeaturedImageToMediaItemConnectionEdge
    "The database identifier for the featured image node assigned to the content node"
    featuredImageDatabaseId: Int
    "Globally unique ID of the featured image assigned to the node"
    featuredImageId: ID
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The unique resource identifier path"
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "The template assigned to a node of content"
    template: ContentTemplate
    "The unique resource identifier path"
    uri: String
}

"A node that can have page attributes"
interface NodeWithPageAttributes {
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
}

"A node that can have revisions"
interface NodeWithRevisions {
    "True if the node is a revision of another node"
    isRevision: Boolean
    "If the current node is a revision, this field exposes the node this is a revision of. Returns null if the node is not a revision of another node."
    revisionOf: NodeWithRevisionsToContentNodeConnectionEdge
}

"A node that can have a template associated with it"
interface NodeWithTemplate {
    "The template assigned to the node"
    template: ContentTemplate
}

"A node that NodeWith a title"
interface NodeWithTitle {
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
}

"A node that can have trackbacks and pingbacks"
interface NodeWithTrackbacks {
    "Whether the pings are open or closed for this particular post."
    pingStatus: String
    "URLs that have been pinged."
    pinged: [String]
    "URLs queued to be pinged."
    toPing: [String]
}

"Terms are nodes within a Taxonomy, used to group and relate other nodes."
interface TermNode {
    "The number of objects connected to the object"
    count: Int
    "Identifies the primary key from the database."
    databaseId: Int!
    "The description of the object"
    description: String
    "Connection between the TermNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedScriptConnection
    "Connection between the TermNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedStylesheetConnection
    "The unique resource identifier path"
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The link to the term"
    link: String
    "The human friendly name of the object."
    name: String
    "An alphanumeric identifier for the object unique to its type."
    slug: String
    "The name of the taxonomy that the object is associated with"
    taxonomyName: String
    "The ID of the term group that this term object belongs to"
    termGroupId: Int
    "The taxonomy ID that the object is associated with"
    termTaxonomyId: Int
    "The unique resource identifier path"
    uri: String
}

"Any node that has a URI"
interface UniformResourceIdentifiable {
    "The unique resource identifier path"
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The unique resource identifier path"
    uri: String
}

"A union of Content Node Types that support revisions"
union ContentRevisionUnion = Page | Post

union Course_Tutorialmanager_Downloads = ResourceLibrary

union Course_Tutorialmanager_Resources = Course_Tutorialmanager_Resources_ColorSwatch | Course_Tutorialmanager_Resources_Course | Course_Tutorialmanager_Resources_Download | Course_Tutorialmanager_Resources_Link | Course_Tutorialmanager_Resources_PaidProduct

union Course_Tutorialmanager_Resources_Course_Course = Course

union Course_Tutorialmanager_Resources_PaidProduct_Product = Product

union DownloadFreebie_Tutorialmanager_Downloads = ResourceLibrary

union DownloadFreebie_Tutorialmanager_Resources = DownloadFreebie_Tutorialmanager_Resources_ColorSwatch | DownloadFreebie_Tutorialmanager_Resources_Course | DownloadFreebie_Tutorialmanager_Resources_Download | DownloadFreebie_Tutorialmanager_Resources_Link | DownloadFreebie_Tutorialmanager_Resources_PaidProduct

union DownloadFreebie_Tutorialmanager_Resources_Course_Course = Course

union DownloadFreebie_Tutorialmanager_Resources_PaidProduct_Product = Product

"Deprecated in favor of MenuItemLinkeable Interface"
union MenuItemObjectUnion = Category | Course | DownloadGrid | Page | Post | PostFormat | Product | ResourceLibrary | SubCategory | Tag | ThingILove

union MenuItem_Featured_Courses = Course

union Post_Tutorialmanager_Downloads = ResourceLibrary

union Post_Tutorialmanager_Resources = Post_Tutorialmanager_Resources_ColorSwatch | Post_Tutorialmanager_Resources_Course | Post_Tutorialmanager_Resources_Download | Post_Tutorialmanager_Resources_Link | Post_Tutorialmanager_Resources_PaidProduct

union Post_Tutorialmanager_Resources_Course_Course = Course

union Post_Tutorialmanager_Resources_PaidProduct_Product = Product

union Product_Tutorialmanager_Downloads = ResourceLibrary

union Product_Tutorialmanager_Resources = Product_Tutorialmanager_Resources_ColorSwatch | Product_Tutorialmanager_Resources_Course | Product_Tutorialmanager_Resources_Download | Product_Tutorialmanager_Resources_Link | Product_Tutorialmanager_Resources_PaidProduct

union Product_Tutorialmanager_Resources_Course_Course = Course

union Product_Tutorialmanager_Resources_PaidProduct_Product = Product

union ResourceLibrary_Freebie_Product = Product

"The payload for the addToWishlist mutation"
type AddToWishlistPayload {
    "True if the product is removed, false otherwise"
    added: Boolean
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Description of the error"
    error: String
    "The Product id that was added"
    productId: Int
    "The Product ids in the wishlist"
    wishlistProductIds: [Int]
}

"Avatars are profile images for users. WordPress by default uses the Gravatar service to host and fetch avatars from."
type Avatar {
    "URL for the default image or a default type. Accepts '404' (return a 404 instead of a default image), 'retro' (8bit), 'monsterid' (monster), 'wavatar' (cartoon face), 'indenticon' (the 'quilt'), 'mystery', 'mm', or 'mysteryman' (The Oyster Man), 'blank' (transparent GIF), or 'gravatar_default' (the Gravatar logo)."
    default: String
    "HTML attributes to insert in the IMG element. Is not sanitized."
    extraAttr: String
    "Whether to always show the default image, never the Gravatar."
    forceDefault: Boolean
    "Whether the avatar was successfully found."
    foundAvatar: Boolean
    "Height of the avatar image."
    height: Int
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "What rating to display avatars up to. Accepts 'G', 'PG', 'R', 'X', and are judged in that order."
    rating: String
    "Type of url scheme to use. Typically HTTP vs. HTTPS."
    scheme: String
    "The size of the avatar in pixels. A value of 96 will match a 96px x 96px gravatar image."
    size: Int
    "URL for the gravatar image source."
    url: String
    "Width of the avatar image."
    width: Int
}

"The category type"
type Category implements DatabaseIdentifier & HierarchicalTermNode & MenuItemLinkable & Node & TermNode & UniformResourceIdentifiable {
    "The ancestors of the node. Default ordered as lowest (closest to the child) to highest (closest to the root)."
    ancestors(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): CategoryToAncestorsCategoryConnection
    "The id field matches the WP_Post->ID field."
    categoryId: Int @deprecated(reason: "Deprecated in favor of databaseId")
    "Connection between the category type and the category type"
    children(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CategoryToCategoryConnectionWhereArgs
    ): CategoryToCategoryConnection
    "Connection between the category type and the ContentNode type"
    contentNodes(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CategoryToContentNodeConnectionWhereArgs
    ): CategoryToContentNodeConnection
    "The number of objects connected to the object"
    count: Int
    "Connection between the category type and the Course type"
    courses(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CategoryToCourseConnectionWhereArgs
    ): CategoryToCourseConnection
    "The unique resource identifier path"
    databaseId: Int!
    "The description of the object"
    description: String
    "Connection between the TermNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedScriptConnection
    "Connection between the TermNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedStylesheetConnection
    "The unique resource identifier path"
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The link to the term"
    link: String
    "The human friendly name of the object."
    name: String
    "Connection between the category type and the category type"
    parent: CategoryToParentCategoryConnectionEdge
    "Database id of the parent node"
    parentDatabaseId: Int
    "The globally unique identifier of the parent node."
    parentId: ID
    "Connection between the category type and the post type"
    posts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CategoryToPostConnectionWhereArgs
    ): CategoryToPostConnection
    "Connection between the category type and the Product type"
    products(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CategoryToProductConnectionWhereArgs
    ): CategoryToProductConnection
    "Connection between the category type and the ResourceLibrary type"
    resourceLibraries(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CategoryToResourceLibraryConnectionWhereArgs
    ): CategoryToResourceLibraryConnection
    "The Yoast SEO data of the Categories taxonomy."
    seo: TaxonomySEO
    "An alphanumeric identifier for the object unique to its type."
    slug: String
    "Connection between the category type and the Taxonomy type"
    taxonomy: CategoryToTaxonomyConnectionEdge
    "The name of the taxonomy that the object is associated with"
    taxonomyName: String
    "The ID of the term group that this term object belongs to"
    termGroupId: Int
    "The taxonomy ID that the object is associated with"
    termTaxonomyId: Int
    "Connection between the category type and the ThingILove type"
    thingsILove(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CategoryToThingILoveConnectionWhereArgs
    ): CategoryToThingILoveConnection
    "The unique resource identifier path"
    uri: String
}

"Connection between the category type and the category type"
type CategoryToAncestorsCategoryConnection {
    "Edges for the CategoryToAncestorsCategoryConnection connection"
    edges: [CategoryToAncestorsCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Category]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CategoryToAncestorsCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Category
}

"Connection between the category type and the category type"
type CategoryToCategoryConnection {
    "Edges for the CategoryToCategoryConnection connection"
    edges: [CategoryToCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Category]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CategoryToCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Category
}

"Connection between the category type and the ContentNode type"
type CategoryToContentNodeConnection {
    "Edges for the CategoryToContentNodeConnection connection"
    edges: [CategoryToContentNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CategoryToContentNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentNode
}

"Connection between the category type and the Course type"
type CategoryToCourseConnection {
    "Edges for the CategoryToCourseConnection connection"
    edges: [CategoryToCourseConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Course]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CategoryToCourseConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Course
}

"Connection between the category type and the category type"
type CategoryToParentCategoryConnectionEdge {
    "The node of the connection, without the edges"
    node: Category
}

"Connection between the category type and the post type"
type CategoryToPostConnection {
    "Edges for the CategoryToPostConnection connection"
    edges: [CategoryToPostConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Post]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CategoryToPostConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Post
}

"Connection between the category type and the Product type"
type CategoryToProductConnection {
    "Edges for the CategoryToProductConnection connection"
    edges: [CategoryToProductConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Product]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CategoryToProductConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Product
}

"Connection between the category type and the ResourceLibrary type"
type CategoryToResourceLibraryConnection {
    "Edges for the CategoryToResourceLibraryConnection connection"
    edges: [CategoryToResourceLibraryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ResourceLibrary]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CategoryToResourceLibraryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ResourceLibrary
}

"Connection between the category type and the Taxonomy type"
type CategoryToTaxonomyConnectionEdge {
    "The node of the connection, without the edges"
    node: Taxonomy
}

"Connection between the category type and the ThingILove type"
type CategoryToThingILoveConnection {
    "Edges for the CategoryToThingILoveConnection connection"
    edges: [CategoryToThingILoveConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ThingILove]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CategoryToThingILoveConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ThingILove
}

"A Comment object"
type Comment implements DatabaseIdentifier & Node {
    "User agent used to post the comment. This field is equivalent to WP_Comment->comment_agent and the value matching the "comment_agent" column in SQL."
    agent: String
    "The approval status of the comment. This field is equivalent to WP_Comment->comment_approved and the value matching the "comment_approved" column in SQL."
    approved: Boolean
    "The author of the comment"
    author: CommentToCommenterConnectionEdge
    "IP address for the author. This field is equivalent to WP_Comment->comment_author_IP and the value matching the "comment_author_IP" column in SQL."
    authorIp: String
    "ID for the comment, unique among comments."
    commentId: Int @deprecated(reason: "Deprecated in favor of databaseId")
    "Connection between the Comment type and the ContentNode type"
    commentedOn: CommentToContentNodeConnectionEdge
    "Content of the comment. This field is equivalent to WP_Comment->comment_content and the value matching the "comment_content" column in SQL."
    content(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "The unique identifier stored in the database"
    databaseId: Int!
    "Date the comment was posted in local time. This field is equivalent to WP_Comment->date and the value matching the "date" column in SQL."
    date: String
    "Date the comment was posted in GMT. This field is equivalent to WP_Comment->date_gmt and the value matching the "date_gmt" column in SQL."
    dateGmt: String
    "The globally unique identifier for the comment object"
    id: ID!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Karma value for the comment. This field is equivalent to WP_Comment->comment_karma and the value matching the "comment_karma" column in SQL."
    karma: Int
    "Connection between the Comment type and the Comment type"
    parent(
        "Arguments for filtering the connection"
        where: CommentToParentCommentConnectionWhereArgs
    ): CommentToParentCommentConnectionEdge
    "The database id of the parent comment node or null if it is the root comment"
    parentDatabaseId: Int
    "The globally unique identifier of the parent comment node."
    parentId: ID
    "Connection between the Comment type and the Comment type"
    replies(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CommentToCommentConnectionWhereArgs
    ): CommentToCommentConnection
    "Type of comment. This field is equivalent to WP_Comment->comment_type and the value matching the "comment_type" column in SQL."
    type: String
}

"A Comment Author object"
type CommentAuthor implements Commenter & Node {
    "Avatar object for user. The avatar object can be retrieved in different sizes by specifying the size argument."
    avatar(
        "Whether to always show the default image, never the Gravatar. Default false"
        forceDefault: Boolean,
        "The rating level of the avatar."
        rating: AvatarRatingEnum,
        "The size attribute of the avatar field can be used to fetch avatars of different sizes. The value corresponds to the dimension in pixels to fetch. The default is 96 pixels."
        size: Int = 96
    ): Avatar
    "Identifies the primary key from the database."
    databaseId: Int!
    "The email for the comment author"
    email: String
    "Avatar MD5"
    gravatar: GravatarType
    "The globally unique identifier for the comment author object"
    id: ID!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "The name for the comment author."
    name: String
    "The url the comment author."
    url: String
}

"Connection between the Comment type and the Comment type"
type CommentToCommentConnection {
    "Edges for the CommentToCommentConnection connection"
    edges: [CommentToCommentConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Comment]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CommentToCommentConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Comment
}

"Connection between the Comment type and the Commenter type"
type CommentToCommenterConnectionEdge {
    "The node of the connection, without the edges"
    node: Commenter
}

"Connection between the Comment type and the ContentNode type"
type CommentToContentNodeConnectionEdge {
    "The node of the connection, without the edges"
    node: ContentNode
}

"Connection between the Comment type and the Comment type"
type CommentToParentCommentConnectionEdge {
    "The node of the connection, without the edges"
    node: Comment
}

"Connection between the ContentNode type and the ContentType type"
type ContentNodeToContentTypeConnectionEdge {
    "The node of the connection, without the edges"
    node: ContentType
}

"Connection between the ContentNode type and the User type"
type ContentNodeToEditLastConnectionEdge {
    "The node of the connection, without the edges"
    node: User
}

"Connection between the ContentNode type and the User type"
type ContentNodeToEditLockConnectionEdge {
    "The timestamp for when the node was last edited"
    lockTimestamp: String
    "The node of the connection, without the edges"
    node: User
}

"Connection between the ContentNode type and the EnqueuedScript type"
type ContentNodeToEnqueuedScriptConnection {
    "Edges for the ContentNodeToEnqueuedScriptConnection connection"
    edges: [ContentNodeToEnqueuedScriptConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [EnqueuedScript]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ContentNodeToEnqueuedScriptConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: EnqueuedScript
}

"Connection between the ContentNode type and the EnqueuedStylesheet type"
type ContentNodeToEnqueuedStylesheetConnection {
    "Edges for the ContentNodeToEnqueuedStylesheetConnection connection"
    edges: [ContentNodeToEnqueuedStylesheetConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [EnqueuedStylesheet]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ContentNodeToEnqueuedStylesheetConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: EnqueuedStylesheet
}

"An Post Type object"
type ContentType implements Node & UniformResourceIdentifiable {
    "Whether this content type should can be exported."
    canExport: Boolean
    "Connection between the ContentType type and the Taxonomy type"
    connectedTaxonomies(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentTypeToTaxonomyConnection
    "Connection between the ContentType type and the ContentNode type"
    contentNodes(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ContentTypeToContentNodeConnectionWhereArgs
    ): ContentTypeToContentNodeConnection
    "Whether content of this type should be deleted when the author of it is deleted from the system."
    deleteWithUser: Boolean
    "Description of the content type."
    description: String
    "Whether to exclude nodes of this content type from front end search results."
    excludeFromSearch: Boolean
    "The plural name of the content type within the GraphQL Schema."
    graphqlPluralName: String
    "The singular name of the content type within the GraphQL Schema."
    graphqlSingleName: String
    "Whether this content type should have archives. Content archives are generated by type and by date."
    hasArchive: Boolean
    "Whether the content type is hierarchical, for example pages."
    hierarchical: Boolean
    "The globally unique identifier of the post-type object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether this page is set to the static front page."
    isFrontPage: Boolean!
    "Whether this page is set to the blog posts page."
    isPostsPage: Boolean!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "Display name of the content type."
    label: String
    "Details about the content type labels."
    labels: PostTypeLabelDetails
    "The name of the icon file to display as a menu icon."
    menuIcon: String
    "The position of this post type in the menu. Only applies if show_in_menu is true."
    menuPosition: Int
    "The internal name of the post type. This should not be used for display purposes."
    name: String
    "Whether a content type is intended for use publicly either via the admin interface or by front-end users. While the default settings of exclude_from_search, publicly_queryable, show_ui, and show_in_nav_menus are inherited from public, each does not rely on this relationship and controls a very specific intention."
    public: Boolean
    "Whether queries can be performed on the front end for the content type as part of parse_request()."
    publiclyQueryable: Boolean
    "Name of content type to display in REST API "wp/v2" namespace."
    restBase: String
    "The REST Controller class assigned to handling this content type."
    restControllerClass: String
    "Makes this content type available via the admin bar."
    showInAdminBar: Boolean
    "Whether to add the content type to the GraphQL Schema."
    showInGraphql: Boolean
    "Where to show the content type in the admin menu. To work, $show_ui must be true. If true, the post type is shown in its own top level menu. If false, no menu is shown. If a string of an existing top level menu (eg. "tools.php" or "edit.php?post_type=page"), the post type will be placed as a sub-menu of that."
    showInMenu: Boolean
    "Makes this content type available for selection in navigation menus."
    showInNavMenus: Boolean
    "Whether the content type is associated with a route under the the REST API "wp/v2" namespace."
    showInRest: Boolean
    "Whether to generate and allow a UI for managing this content type in the admin."
    showUi: Boolean
    "The unique resource identifier path"
    uri: String
}

"Connection between the ContentType type and the ContentNode type"
type ContentTypeToContentNodeConnection {
    "Edges for the ContentTypeToContentNodeConnection connection"
    edges: [ContentTypeToContentNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ContentTypeToContentNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentNode
}

"Connection between the ContentType type and the Taxonomy type"
type ContentTypeToTaxonomyConnection {
    "Edges for the ContentTypeToTaxonomyConnection connection"
    edges: [ContentTypeToTaxonomyConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Taxonomy]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ContentTypeToTaxonomyConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Taxonomy
}

"The Course type"
type Course implements ContentNode & DatabaseIdentifier & MenuItemLinkable & Node & NodeWithContentEditor & NodeWithFeaturedImage & NodeWithTemplate & NodeWithTitle & UniformResourceIdentifiable {
    "Connection between the Course type and the category type"
    categories(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CourseToCategoryConnectionWhereArgs
    ): CourseToCategoryConnection
    "The content of the post."
    content(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The id field matches the WP_Post->ID field."
    courseId: Int! @deprecated(reason: "Deprecated in favor of the databaseId field")
    "The unique resource identifier path"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "Added to the GraphQL Schema because the ACF Field Group "Courses" was set to Show in GraphQL."
    details: Course_Details
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "Connection between the NodeWithFeaturedImage type and the MediaItem type"
    featuredImage: NodeWithFeaturedImageToMediaItemConnectionEdge
    "The database identifier for the featured image node assigned to the content node"
    featuredImageDatabaseId: Int
    "Globally unique ID of the featured image assigned to the node"
    featuredImageId: ID
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The globally unique identifier of the courses object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "Connection between the Course type and the Course type"
    preview: CourseToPreviewConnectionEdge
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "Connection between the Course type and the tag type"
    tags(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CourseToTagConnectionWhereArgs
    ): CourseToTagConnection
    "The template assigned to a node of content"
    template: ContentTemplate
    "Connection between the Course type and the TermNode type"
    terms(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: CourseToTermNodeConnectionWhereArgs
    ): CourseToTermNodeConnection
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "Added to the GraphQL Schema because the ACF Field Group "Tutorial Manager" was set to Show in GraphQL."
    tutorialManager: Course_Tutorialmanager
    "The unique resource identifier path"
    uri: String
}

"Connection between the Course type and the category type"
type CourseToCategoryConnection {
    "Edges for the CourseToCategoryConnection connection"
    edges: [CourseToCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Category]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CourseToCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary category"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: Category
}

"Connection between the Course type and the Course type"
type CourseToPreviewConnectionEdge {
    "The node of the connection, without the edges"
    node: Course
}

"Connection between the Course type and the tag type"
type CourseToTagConnection {
    "Edges for the CourseToTagConnection connection"
    edges: [CourseToTagConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Tag]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CourseToTagConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary post_tag"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: Tag
}

"Connection between the Course type and the TermNode type"
type CourseToTermNodeConnection {
    "Edges for the CourseToTermNodeConnection connection"
    edges: [CourseToTermNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [TermNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type CourseToTermNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: TermNode
}

"Field Group"
type Course_Details implements AcfFieldGroup {
    "Add tags here"
    courseTags: [Course_Details_courseTags]
    "Add Course URL"
    courseUrl: String
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type Course_Details_courseTags implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Add Item for each tag"
    tag: String
}

"Field Group"
type Course_Tutorialmanager implements AcfFieldGroup {
    "Select Freebies included in the tutorial that are located in the Tuesday Tribe Resource Library"
    downloads: [Course_Tutorialmanager_Downloads]
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Add post excerpt here. The part above the Read Me dotted line."
    postExcerpt: String
    "Short Summary of the tutorial in 280 characters or less"
    quickSummary: String
    "Extra Resources in the tutorial that need to be clickable - ie courses, free PDFS, or paid product links"
    resources: [Course_Tutorialmanager_Resources]
    youtube: Course_Tutorialmanager_Youtube
}

"Group within the flex field"
type Course_Tutorialmanager_Resources_ColorSwatch implements AcfFieldGroup {
    colorSwatch: Course_Tutorialmanager_Resources_ColorSwatch_ColorSwatch
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type Course_Tutorialmanager_Resources_ColorSwatch_ColorSwatch implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    url: String
}

"Group within the flex field"
type Course_Tutorialmanager_Resources_Course implements AcfFieldGroup {
    course: Course_Tutorialmanager_Resources_Course_Course
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Group within the flex field"
type Course_Tutorialmanager_Resources_Download implements AcfFieldGroup {
    download: Course_Tutorialmanager_Resources_Download_Download
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type Course_Tutorialmanager_Resources_Download_Download implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    url: String
}

"Group within the flex field"
type Course_Tutorialmanager_Resources_Link implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    link: Course_Tutorialmanager_Resources_Link_Link
}

"Field Group"
type Course_Tutorialmanager_Resources_Link_Link implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    url: String
}

"Group within the flex field"
type Course_Tutorialmanager_Resources_PaidProduct implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    product: Course_Tutorialmanager_Resources_PaidProduct_Product
}

"Field Group"
type Course_Tutorialmanager_Youtube implements AcfFieldGroup {
    addVideoMetadata: Boolean
    "Duration of the video. Example 1 min 38 seconds should be entered in as 1:38"
    duration: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    id: String
    "Add Video Meta Data to the page"
    videoObject: Course_Tutorialmanager_Youtube_VideoObject
}

"Field Group"
type Course_Tutorialmanager_Youtube_VideoObject implements AcfFieldGroup {
    clipElements: [Course_Tutorialmanager_Youtube_VideoObject_clipElements]
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    "If the video doesn't have chapters, use this method as an alternate way."
    potentialActions: [Course_Tutorialmanager_Youtube_VideoObject_potentialActions]
    "Grab the URL of the highest rez thumbnail possible"
    thumbnailUrl: String
    "Video publish date"
    uploadDate: String
}

"Field Group"
type Course_Tutorialmanager_Youtube_VideoObject_clipElements implements AcfFieldGroup {
    "Ex: 1 min 32 sec = 1:32"
    endOffset: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    "Ex: 1 min 32 sec = 1:32"
    startOffset: String
}

"Field Group"
type Course_Tutorialmanager_Youtube_VideoObject_potentialActions implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    "Ex: 1 min 38 seconds should be entered in as 1:38"
    startOffset: String
}

"CPT Tag Object"
type Cpt_tag {
    "Tag Name"
    name: String
    "Tag Slug"
    slug: String
}

"The payload for the createCategory mutation"
type CreateCategoryPayload {
    "The created category"
    category: Category
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
}

"The payload for the createComment mutation"
type CreateCommentPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The comment that was created"
    comment: Comment
    "Whether the mutation succeeded. If the comment is not approved, the server will not return the comment to a non authenticated user, but a success message can be returned if the create succeeded, and the client can optimistically add the comment to the client cache"
    success: Boolean
}

"The payload for the createCourse mutation"
type CreateCoursePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    course: Course
}

"The payload for the createDownloadFreebie mutation"
type CreateDownloadFreebiePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    downloadFreebie: DownloadFreebie
}

"The payload for the createDownloadGrid mutation"
type CreateDownloadGridPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    downloadGrid: DownloadGrid
}

"The payload for the createMediaItem mutation"
type CreateMediaItemPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The MediaItem object mutation type."
    mediaItem: MediaItem
}

"The payload for the createPage mutation"
type CreatePagePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    page: Page
}

"The payload for the createPostFormat mutation"
type CreatePostFormatPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The created post_format"
    postFormat: PostFormat
}

"The payload for the createPost mutation"
type CreatePostPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    post: Post
}

"The payload for the createProduct mutation"
type CreateProductPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    product: Product
}

"The payload for the createResourceLibrary mutation"
type CreateResourceLibraryPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    resourceLibrary: ResourceLibrary
}

"The payload for the createSubCategory mutation"
type CreateSubCategoryPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The created subcategory"
    subCategory: SubCategory
}

"The payload for the createTag mutation"
type CreateTagPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The created post_tag"
    tag: Tag
}

"The payload for the createThingILove mutation"
type CreateThingILovePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    thingILove: ThingILove
}

"The payload for the createUser mutation"
type CreateUserPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The User object mutation type."
    user: User
}

"The template assigned to the node"
type DefaultTemplate implements ContentTemplate {
    "The name of the template"
    templateName: String
}

"The payload for the deleteCategory mutation"
type DeleteCategoryPayload {
    "The deteted term object"
    category: Category
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
}

"The payload for the deleteComment mutation"
type DeleteCommentPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The deleted comment object"
    comment: Comment
    "The deleted comment ID"
    deletedId: ID
}

"The payload for the deleteCourse mutation"
type DeleteCoursePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The object before it was deleted"
    course: Course
    "The ID of the deleted object"
    deletedId: ID
}

"The payload for the deleteDownloadFreebie mutation"
type DeleteDownloadFreebiePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The object before it was deleted"
    downloadFreebie: DownloadFreebie
}

"The payload for the deleteDownloadGrid mutation"
type DeleteDownloadGridPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The object before it was deleted"
    downloadGrid: DownloadGrid
}

"The payload for the deleteMediaItem mutation"
type DeleteMediaItemPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted mediaItem"
    deletedId: ID
    "The mediaItem before it was deleted"
    mediaItem: MediaItem
}

"The payload for the deletePage mutation"
type DeletePagePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The object before it was deleted"
    page: Page
}

"The payload for the deletePostFormat mutation"
type DeletePostFormatPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The deteted term object"
    postFormat: PostFormat
}

"The payload for the deletePost mutation"
type DeletePostPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The object before it was deleted"
    post: Post
}

"The payload for the deleteProduct mutation"
type DeleteProductPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The object before it was deleted"
    product: Product
}

"The payload for the deleteResourceLibrary mutation"
type DeleteResourceLibraryPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The object before it was deleted"
    resourceLibrary: ResourceLibrary
}

"The payload for the deleteSubCategory mutation"
type DeleteSubCategoryPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The deteted term object"
    subCategory: SubCategory
}

"The payload for the deleteTag mutation"
type DeleteTagPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The deteted term object"
    tag: Tag
}

"The payload for the deleteThingILove mutation"
type DeleteThingILovePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the deleted object"
    deletedId: ID
    "The object before it was deleted"
    thingILove: ThingILove
}

"The payload for the deleteUser mutation"
type DeleteUserPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the user that you just deleted"
    deletedId: ID
    "The deleted user object"
    user: User
}

"The discussion setting type"
type DiscussionSettings {
    "Allow people to submit comments on new posts."
    defaultCommentStatus: String
    "Allow link notifications from other blogs (pingbacks and trackbacks) on new articles."
    defaultPingStatus: String
}

"The downloadFreebie type"
type DownloadFreebie implements ContentNode & DatabaseIdentifier & Node & NodeWithTemplate & NodeWithTitle & UniformResourceIdentifiable {
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The unique identifier stored in the database"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "Added to the GraphQL Schema because the ACF Field Group "Download Details" was set to Show in GraphQL."
    downloadDetails: DownloadFreebie_Downloaddetails
    "The id field matches the WP_Post->ID field."
    downloadFreebieId: Int! @deprecated(reason: "Deprecated in favor of the databaseId field")
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The globally unique identifier of the etdm_download object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "Connection between the downloadFreebie type and the downloadFreebie type"
    preview: DownloadFreebieToPreviewConnectionEdge
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "The template assigned to the node"
    template: ContentTemplate
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "Added to the GraphQL Schema because the ACF Field Group "Tutorial Manager" was set to Show in GraphQL."
    tutorialManager: DownloadFreebie_Tutorialmanager
    "The unique resource identifier path"
    uri: String
}

"Connection between the downloadFreebie type and the downloadFreebie type"
type DownloadFreebieToPreviewConnectionEdge {
    "The node of the connection, without the edges"
    node: DownloadFreebie
}

"Field Group"
type DownloadFreebie_Downloaddetails implements AcfFieldGroup {
    etdmCampaign: String
    etdmDescriptor: String
    etdmFileSize: String
    etdmFileType: String
    etdmLink: String
    etdmSsVersion: String
    etdmTitle: String
    etdmVersion: String
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type DownloadFreebie_Tutorialmanager implements AcfFieldGroup {
    "Select Freebies included in the tutorial that are located in the Tuesday Tribe Resource Library"
    downloads: [DownloadFreebie_Tutorialmanager_Downloads]
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Add post excerpt here. The part above the Read Me dotted line."
    postExcerpt: String
    "Short Summary of the tutorial in 280 characters or less"
    quickSummary: String
    "Extra Resources in the tutorial that need to be clickable - ie courses, free PDFS, or paid product links"
    resources: [DownloadFreebie_Tutorialmanager_Resources]
    youtube: DownloadFreebie_Tutorialmanager_Youtube
}

"Group within the flex field"
type DownloadFreebie_Tutorialmanager_Resources_ColorSwatch implements AcfFieldGroup {
    colorSwatch: DownloadFreebie_Tutorialmanager_Resources_ColorSwatch_ColorSwatch
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type DownloadFreebie_Tutorialmanager_Resources_ColorSwatch_ColorSwatch implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    url: String
}

"Group within the flex field"
type DownloadFreebie_Tutorialmanager_Resources_Course implements AcfFieldGroup {
    course: DownloadFreebie_Tutorialmanager_Resources_Course_Course
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Group within the flex field"
type DownloadFreebie_Tutorialmanager_Resources_Download implements AcfFieldGroup {
    download: DownloadFreebie_Tutorialmanager_Resources_Download_Download
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type DownloadFreebie_Tutorialmanager_Resources_Download_Download implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    url: String
}

"Group within the flex field"
type DownloadFreebie_Tutorialmanager_Resources_Link implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    link: DownloadFreebie_Tutorialmanager_Resources_Link_Link
}

"Field Group"
type DownloadFreebie_Tutorialmanager_Resources_Link_Link implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    url: String
}

"Group within the flex field"
type DownloadFreebie_Tutorialmanager_Resources_PaidProduct implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    product: DownloadFreebie_Tutorialmanager_Resources_PaidProduct_Product
}

"Field Group"
type DownloadFreebie_Tutorialmanager_Youtube implements AcfFieldGroup {
    addVideoMetadata: Boolean
    "Duration of the video. Example 1 min 38 seconds should be entered in as 1:38"
    duration: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    id: String
    "Add Video Meta Data to the page"
    videoObject: DownloadFreebie_Tutorialmanager_Youtube_VideoObject
}

"Field Group"
type DownloadFreebie_Tutorialmanager_Youtube_VideoObject implements AcfFieldGroup {
    clipElements: [DownloadFreebie_Tutorialmanager_Youtube_VideoObject_clipElements]
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    "If the video doesn't have chapters, use this method as an alternate way."
    potentialActions: [DownloadFreebie_Tutorialmanager_Youtube_VideoObject_potentialActions]
    "Grab the URL of the highest rez thumbnail possible"
    thumbnailUrl: String
    "Video publish date"
    uploadDate: String
}

"Field Group"
type DownloadFreebie_Tutorialmanager_Youtube_VideoObject_clipElements implements AcfFieldGroup {
    "Ex: 1 min 32 sec = 1:32"
    endOffset: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    "Ex: 1 min 32 sec = 1:32"
    startOffset: String
}

"Field Group"
type DownloadFreebie_Tutorialmanager_Youtube_VideoObject_potentialActions implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    "Ex: 1 min 38 seconds should be entered in as 1:38"
    startOffset: String
}

"The DownloadGrid type"
type DownloadGrid implements ContentNode & DatabaseIdentifier & MenuItemLinkable & Node & NodeWithTemplate & NodeWithTitle & UniformResourceIdentifiable {
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The unique resource identifier path"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "The id field matches the WP_Post->ID field."
    downloadGridId: Int! @deprecated(reason: "Deprecated in favor of the databaseId field")
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "Added to the GraphQL Schema because the ACF Field Group "Resource Grids" was set to Show in GraphQL."
    grid: DownloadGrid_Grid
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The globally unique identifier of the downloadgrid object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "Added to the GraphQL Schema because the ACF Field Group "Page" was set to Show in GraphQL."
    page: DownloadGrid_Page
    "Connection between the DownloadGrid type and the DownloadGrid type"
    preview: DownloadGridToPreviewConnectionEdge
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "Connection between the DownloadGrid type and the tag type"
    tags(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: DownloadGridToTagConnectionWhereArgs
    ): DownloadGridToTagConnection
    "The template assigned to the node"
    template: ContentTemplate
    "Connection between the DownloadGrid type and the TermNode type"
    terms(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: DownloadGridToTermNodeConnectionWhereArgs
    ): DownloadGridToTermNodeConnection
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "The unique resource identifier path"
    uri: String
}

"Connection between the DownloadGrid type and the DownloadGrid type"
type DownloadGridToPreviewConnectionEdge {
    "The node of the connection, without the edges"
    node: DownloadGrid
}

"Connection between the DownloadGrid type and the tag type"
type DownloadGridToTagConnection {
    "Edges for the DownloadGridToTagConnection connection"
    edges: [DownloadGridToTagConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Tag]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type DownloadGridToTagConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary post_tag"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: Tag
}

"Connection between the DownloadGrid type and the TermNode type"
type DownloadGridToTermNodeConnection {
    "Edges for the DownloadGridToTermNodeConnection connection"
    edges: [DownloadGridToTermNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [TermNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type DownloadGridToTermNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: TermNode
}

"Field Group"
type DownloadGrid_Grid implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    items: [DownloadGrid_Grid_items]
}

"Field Group"
type DownloadGrid_Grid_items implements AcfFieldGroup {
    downloadLink: String
    excerpt: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    image: MediaItem
    tags: [Tag]
    title: String
}

"Field Group"
type DownloadGrid_Page implements AcfFieldGroup {
    "Add the Cookie name and login key that gets set here"
    cookie: DownloadGrid_Page_Cookie
    "The name of the ACF Field Group"
    fieldGroupName: String
    password: String
}

"Field Group"
type DownloadGrid_Page_Cookie implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    key: String
    name: String
}

"Script enqueued by the CMS"
type EnqueuedScript implements EnqueuedAsset & Node {
    "@todo"
    args: Boolean
    "Dependencies needed to use this asset"
    dependencies: [EnqueuedScript]
    "Extra information needed for the script"
    extra: String
    "The handle of the enqueued asset"
    handle: String
    "The ID of the enqueued asset"
    id: ID!
    "The source of the asset"
    src: String
    "The version of the enqueued asset"
    version: String
}

"Stylesheet enqueued by the CMS"
type EnqueuedStylesheet implements EnqueuedAsset & Node {
    "@todo"
    args: Boolean
    "Dependencies needed to use this asset"
    dependencies: [EnqueuedScript]
    "Extra information needed for the script"
    extra: String
    "The handle of the enqueued asset"
    handle: String
    "The ID of the enqueued asset"
    id: ID!
    "The source of the asset"
    src: String
    "The version of the enqueued asset"
    version: String
}

"The general setting type"
type GeneralSettings {
    "A date format for all date strings."
    dateFormat: String
    "Site tagline."
    description: String
    "This address is used for admin purposes, like new user notification."
    email: String
    "WordPress locale code."
    language: String
    "A day number of the week that the week should start on."
    startOfWeek: Int
    "A time format for all time strings."
    timeFormat: String
    "A city in the same timezone as you."
    timezone: String
    "Site title."
    title: String
    "Site URL."
    url: String
}

"Gravatar"
type GravatarType {
    "mm"
    default: String
    "Extras"
    extra_attr: String
    "Force the default image"
    force_default: Boolean
    "Found avatar"
    found_avatar: Boolean
    "Image Height"
    height: Int
    "image rating"
    rating: String
    "Image Size"
    size: Int
    "Url for the Avatar"
    url: String
    "Image Width"
    width: Int
}

"Grid Tag Object"
type GridTag {
    "Tag Name"
    name: String
    "Tag Slug"
    slug: String
}

"Header Type"
type HCMSFooter {
    "Copyright text"
    copyrightText: String
    "sidebarOne"
    sidebarOne: String
    "sidebarTwo"
    sidebarTwo: String
    "Social links"
    socialLinks: [HCMSSocialLinks]
}

"Header Type"
type HCMSHeader {
    "favicon"
    favicon: String
    "Site logo URL"
    siteLogoUrl: String
    "Site tagline"
    siteTagLine: String
    "Site title"
    siteTitle: String
}

"Social Links Type"
type HCMSSocialLinks {
    "Icon name"
    iconName: String
    "Icon url"
    iconUrl: String
}

"Connection between the HierarchicalContentNode type and the ContentNode type"
type HierarchicalContentNodeToContentNodeAncestorsConnection {
    "Edges for the HierarchicalContentNodeToContentNodeAncestorsConnection connection"
    edges: [HierarchicalContentNodeToContentNodeAncestorsConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type HierarchicalContentNodeToContentNodeAncestorsConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentNode
}

"Connection between the HierarchicalContentNode type and the ContentNode type"
type HierarchicalContentNodeToContentNodeChildrenConnection {
    "Edges for the HierarchicalContentNodeToContentNodeChildrenConnection connection"
    edges: [HierarchicalContentNodeToContentNodeChildrenConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type HierarchicalContentNodeToContentNodeChildrenConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentNode
}

"Connection between the HierarchicalContentNode type and the ContentNode type"
type HierarchicalContentNodeToParentContentNodeConnectionEdge {
    "The node of the connection, without the edges"
    node: ContentNode
}

"The payload for the login mutation"
type LoginPayload {
    "JWT Token that can be used in future requests for Authentication"
    authToken: String
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "A JWT token that can be used in future requests to get a refreshed jwtAuthToken. If the refresh token used in a request is revoked or otherwise invalid, a valid Auth token will NOT be issued in the response headers."
    refreshToken: String
    "The user that was logged in"
    user: User
}

"The payload for the loginWithCookies mutation"
type LoginWithCookiesPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Login operation status"
    status: String
}

"The payload for the logout mutation"
type LogoutPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Logout operation status"
    status: String
}

"File details for a Media Item"
type MediaDetails {
    "The filename of the mediaItem"
    file: String
    "The height of the mediaItem"
    height: Int
    "Meta information associated with the mediaItem"
    meta: MediaItemMeta
    "The available sizes of the mediaItem"
    sizes: [MediaSize]
    "The width of the mediaItem"
    width: Int
}

"The mediaItem type"
type MediaItem implements ContentNode & DatabaseIdentifier & HierarchicalContentNode & Node & NodeWithAuthor & NodeWithComments & NodeWithTemplate & NodeWithTitle & UniformResourceIdentifiable {
    "Alternative text to display when resource is not displayed"
    altText: String
    "Returns ancestors of the node. Default ordered as lowest (closest to the child) to highest (closest to the root)."
    ancestors(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: HierarchicalContentNodeToContentNodeAncestorsConnectionWhereArgs
    ): HierarchicalContentNodeToContentNodeAncestorsConnection
    "Connection between the NodeWithAuthor type and the User type"
    author: NodeWithAuthorToUserConnectionEdge
    "The database identifier of the author of the node"
    authorDatabaseId: Int
    "The globally unique identifier of the author of the node"
    authorId: ID
    "The caption for the resource"
    caption(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "Connection between the HierarchicalContentNode type and the ContentNode type"
    children(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: HierarchicalContentNodeToContentNodeChildrenConnectionWhereArgs
    ): HierarchicalContentNodeToContentNodeChildrenConnection
    "The number of comments. Even though WPGraphQL denotes this field as an integer, in WordPress this field should be saved as a numeric string for compatibility."
    commentCount: Int
    "Whether the comments are open or closed for this particular post."
    commentStatus: String
    "Connection between the mediaItem type and the Comment type"
    comments(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: MediaItemToCommentConnectionWhereArgs
    ): MediaItemToCommentConnection
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The unique identifier stored in the database"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "Description of the image (stored as post_content)"
    description(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "The desired slug of the post"
    desiredSlug: String
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "The filesize in bytes of the resource"
    fileSize(
        "Size of the MediaItem to return"
        size: MediaItemSizeEnum
    ): Int
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The globally unique identifier of the attachment object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "Details about the mediaItem"
    mediaDetails: MediaDetails
    "The id field matches the WP_Post->ID field."
    mediaItemId: Int! @deprecated(reason: "Deprecated in favor of the databaseId field")
    "Url of the mediaItem"
    mediaItemUrl: String
    "Type of resource"
    mediaType: String
    "The mime type of the mediaItem"
    mimeType: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "The parent of the node. The parent object can be of various types"
    parent: HierarchicalContentNodeToParentContentNodeConnectionEdge
    "Database id of the parent node"
    parentDatabaseId: Int
    "The globally unique identifier of the parent node."
    parentId: ID
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The sizes attribute value for an image."
    sizes(
        "Size of the MediaItem to calculate sizes with"
        size: MediaItemSizeEnum
    ): String
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "Url of the mediaItem"
    sourceUrl(
        "Size of the MediaItem to return"
        size: MediaItemSizeEnum
    ): String
    "The srcset attribute specifies the URL of the image to use in different situations. It is a comma separated string of urls and their widths."
    srcSet(
        "Size of the MediaItem to calculate srcSet with"
        size: MediaItemSizeEnum
    ): String
    "The current status of the object"
    status: String
    "The template assigned to the node"
    template: ContentTemplate
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "The unique resource identifier path"
    uri: String
}

"Meta connected to a MediaItem"
type MediaItemMeta {
    "Aperture measurement of the media item."
    aperture: Float
    "Information about the camera used to create the media item."
    camera: String
    "The text string description associated with the media item."
    caption: String
    "Copyright information associated with the media item."
    copyright: String
    "The date/time when the media was created."
    createdTimestamp: Int
    "The original creator of the media item."
    credit: String
    "The focal length value of the media item."
    focalLength: Float
    "The ISO (International Organization for Standardization) value of the media item."
    iso: Int
    "List of keywords used to describe or identfy the media item."
    keywords: [String]
    "The vertical or horizontal aspect of the media item."
    orientation: String
    "The shutter speed information of the media item."
    shutterSpeed: Float
    "A useful title for the media item."
    title: String
}

"Connection between the mediaItem type and the Comment type"
type MediaItemToCommentConnection {
    "Edges for the MediaItemToCommentConnection connection"
    edges: [MediaItemToCommentConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Comment]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type MediaItemToCommentConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Comment
}

"Details of an available size for a media item"
type MediaSize {
    "The filename of the referenced size"
    file: String
    "The filesize of the resource"
    fileSize: Int
    "The height of the referenced size"
    height: String
    "The mime type of the referenced size"
    mimeType: String
    "The referenced size name"
    name: String
    "The url of the referenced size"
    sourceUrl: String
    "The width of the referenced size"
    width: String
}

"Menus are the containers for navigation items. Menus can be assigned to menu locations, which are typically registered by the active theme."
type Menu implements DatabaseIdentifier & Node {
    "The number of items in the menu"
    count: Int
    "The unique identifier stored in the database"
    databaseId: Int!
    "The globally unique identifier of the nav menu object."
    id: ID!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "The locations a menu is assigned to"
    locations: [MenuLocationEnum]
    "WP ID of the nav menu."
    menuId: Int @deprecated(reason: "Deprecated in favor of the databaseId field")
    "Connection between the Menu type and the MenuItem type"
    menuItems(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: MenuToMenuItemConnectionWhereArgs
    ): MenuToMenuItemConnection
    "Display name of the menu. Equivalent to WP_Term->name."
    name: String
    "The url friendly name of the menu. Equivalent to WP_Term->slug"
    slug: String
}

"Navigation menu items are the individual items assigned to a menu. These are rendered as the links in a navigation menu."
type MenuItem implements DatabaseIdentifier & Node {
    "Connection between the MenuItem type and the MenuItem type"
    childItems(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: MenuItemToMenuItemConnectionWhereArgs
    ): MenuItemToMenuItemConnection
    "Connection from MenuItem to it's connected node"
    connectedNode: MenuItemToMenuItemLinkableConnectionEdge
    "The object connected to this menu item."
    connectedObject: MenuItemObjectUnion @deprecated(reason: "Deprecated in favor of the connectedNode field")
    "Class attribute for the menu item link"
    cssClasses: [String]
    "The unique identifier stored in the database"
    databaseId: Int!
    "Description of the menu item."
    description: String
    "Added to the GraphQL Schema because the ACF Field Group "featured" was set to Show in GraphQL."
    featured: MenuItem_Featured
    "The globally unique identifier of the nav menu item object."
    id: ID!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Label or title of the menu item."
    label: String
    "Link relationship (XFN) of the menu item."
    linkRelationship: String
    "The locations the menu item's Menu is assigned to"
    locations: [MenuLocationEnum]
    "The Menu a MenuItem is part of"
    menu: MenuItemToMenuConnectionEdge
    "WP ID of the menu item."
    menuItemId: Int @deprecated(reason: "Deprecated in favor of the databaseId field")
    "Menu item order"
    order: Int
    "The database id of the parent menu item or null if it is the root"
    parentDatabaseId: Int
    "The globally unique identifier of the parent nav menu item object."
    parentId: ID
    "Path for the resource. Relative path for internal resources. Absolute path for external resources."
    path: String
    "Target attribute for the menu item link."
    target: String
    "Title attribute for the menu item link"
    title: String
    "The uri of the resource the menu item links to"
    uri: String
    "URL or destination of the menu item."
    url: String
}

"Connection between the MenuItem type and the Menu type"
type MenuItemToMenuConnectionEdge {
    "The node of the connection, without the edges"
    node: Menu
}

"Connection between the MenuItem type and the MenuItem type"
type MenuItemToMenuItemConnection {
    "Edges for the MenuItemToMenuItemConnection connection"
    edges: [MenuItemToMenuItemConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [MenuItem]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type MenuItemToMenuItemConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: MenuItem
}

"Connection between the MenuItem type and the MenuItemLinkable type"
type MenuItemToMenuItemLinkableConnectionEdge {
    "The node of the connection, without the edges"
    node: MenuItemLinkable
}

"Field Group"
type MenuItem_Featured implements AcfFieldGroup {
    courses: [MenuItem_Featured_Courses]
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Connection between the Menu type and the MenuItem type"
type MenuToMenuItemConnection {
    "Edges for the MenuToMenuItemConnection connection"
    edges: [MenuToMenuItemConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [MenuItem]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type MenuToMenuItemConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: MenuItem
}

"Connection between the NodeWithAuthor type and the User type"
type NodeWithAuthorToUserConnectionEdge {
    "The node of the connection, without the edges"
    node: User
}

"Connection between the NodeWithFeaturedImage type and the MediaItem type"
type NodeWithFeaturedImageToMediaItemConnectionEdge {
    "The node of the connection, without the edges"
    node: MediaItem
}

"Connection between the NodeWithRevisions type and the ContentNode type"
type NodeWithRevisionsToContentNodeConnectionEdge {
    "The node of the connection, without the edges"
    node: ContentNode
}

"The page type"
type Page implements ContentNode & DatabaseIdentifier & HierarchicalContentNode & MenuItemLinkable & Node & NodeWithAuthor & NodeWithComments & NodeWithContentEditor & NodeWithFeaturedImage & NodeWithPageAttributes & NodeWithRevisions & NodeWithTemplate & NodeWithTitle & UniformResourceIdentifiable {
    "Returns ancestors of the node. Default ordered as lowest (closest to the child) to highest (closest to the root)."
    ancestors(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: HierarchicalContentNodeToContentNodeAncestorsConnectionWhereArgs
    ): HierarchicalContentNodeToContentNodeAncestorsConnection
    "Connection between the NodeWithAuthor type and the User type"
    author: NodeWithAuthorToUserConnectionEdge
    "The database identifier of the author of the node"
    authorDatabaseId: Int
    "The globally unique identifier of the author of the node"
    authorId: ID
    "bodyClasses"
    bodyClasses: String
    "Connection between the HierarchicalContentNode type and the ContentNode type"
    children(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: HierarchicalContentNodeToContentNodeChildrenConnectionWhereArgs
    ): HierarchicalContentNodeToContentNodeChildrenConnection
    "The number of comments. Even though WPGraphQL denotes this field as an integer, in WordPress this field should be saved as a numeric string for compatibility."
    commentCount: Int
    "Whether the comments are open or closed for this particular post."
    commentStatus: String
    "Connection between the page type and the Comment type"
    comments(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PageToCommentConnectionWhereArgs
    ): PageToCommentConnection
    "The content of the post."
    content(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The unique resource identifier path"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "Connection between the NodeWithFeaturedImage type and the MediaItem type"
    featuredImage: NodeWithFeaturedImageToMediaItemConnectionEdge
    "The database identifier for the featured image node assigned to the content node"
    featuredImageDatabaseId: Int
    "Globally unique ID of the featured image assigned to the node"
    featuredImageId: ID
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The globally unique identifier of the page object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether this page is set to the static front page."
    isFrontPage: Boolean!
    "Whether this page is set to the blog posts page."
    isPostsPage: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether this page is set to the privacy page."
    isPrivacyPage: Boolean!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "True if the node is a revision of another node"
    isRevision: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "The id field matches the WP_Post->ID field."
    pageId: Int! @deprecated(reason: "Deprecated in favor of the databaseId field")
    "The parent of the node. The parent object can be of various types"
    parent: HierarchicalContentNodeToParentContentNodeConnectionEdge
    "Database id of the parent node"
    parentDatabaseId: Int
    "The globally unique identifier of the parent node."
    parentId: ID
    "Connection between the page type and the page type"
    preview: PageToPreviewConnectionEdge
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "If the current node is a revision, this field exposes the node this is a revision of. Returns null if the node is not a revision of another node."
    revisionOf: NodeWithRevisionsToContentNodeConnectionEdge
    "Connection between the page type and the page type"
    revisions(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PageToRevisionConnectionWhereArgs
    ): PageToRevisionConnection
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "The template assigned to a node of content"
    template: ContentTemplate
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "The unique resource identifier path"
    uri: String
}

"Connection between the page type and the Comment type"
type PageToCommentConnection {
    "Edges for the PageToCommentConnection connection"
    edges: [PageToCommentConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Comment]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PageToCommentConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Comment
}

"Connection between the page type and the page type"
type PageToPreviewConnectionEdge {
    "The node of the connection, without the edges"
    node: Page
}

"Connection between the page type and the page type"
type PageToRevisionConnection {
    "Edges for the pageToRevisionConnection connection"
    edges: [PageToRevisionConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Page]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PageToRevisionConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Page
}

"An plugin object"
type Plugin implements Node {
    "Name of the plugin author(s), may also be a company name."
    author: String
    "URI for the related author(s)/company website."
    authorUri: String
    "Description of the plugin."
    description: String
    "The globally unique identifier of the plugin object."
    id: ID!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Display name of the plugin."
    name: String
    "Plugin path."
    path: String
    "URI for the plugin website. This is useful for directing users for support requests etc."
    pluginUri: String
    "Current version of the plugin."
    version: String
}

"The post type"
type Post implements ContentNode & DatabaseIdentifier & MenuItemLinkable & Node & NodeWithAuthor & NodeWithComments & NodeWithContentEditor & NodeWithExcerpt & NodeWithFeaturedImage & NodeWithRevisions & NodeWithTemplate & NodeWithTitle & NodeWithTrackbacks & UniformResourceIdentifiable {
    "Connection between the NodeWithAuthor type and the User type"
    author: NodeWithAuthorToUserConnectionEdge
    "The database identifier of the author of the node"
    authorDatabaseId: Int
    "The globally unique identifier of the author of the node"
    authorId: ID
    "bodyClasses"
    bodyClasses: String
    "Connection between the post type and the category type"
    categories(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PostToCategoryConnectionWhereArgs
    ): PostToCategoryConnection
    "Co Authors"
    coAuthors: String
    "The number of comments. Even though WPGraphQL denotes this field as an integer, in WordPress this field should be saved as a numeric string for compatibility."
    commentCount: Int
    "Whether the comments are open or closed for this particular post."
    commentStatus: String
    "Connection between the post type and the Comment type"
    comments(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PostToCommentConnectionWhereArgs
    ): PostToCommentConnection
    "The content of the post."
    content(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The unique resource identifier path"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "Added to the GraphQL Schema because the ACF Field Group "EveryTuesday Social Nav Options" was set to Show in GraphQL."
    etSocialNav: Post_Etsocialnav
    "The excerpt of the post."
    excerpt(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "Connection between the NodeWithFeaturedImage type and the MediaItem type"
    featuredImage: NodeWithFeaturedImageToMediaItemConnectionEdge
    "The database identifier for the featured image node assigned to the content node"
    featuredImageDatabaseId: Int
    "Globally unique ID of the featured image assigned to the node"
    featuredImageId: ID
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The globally unique identifier of the post object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "True if the node is a revision of another node"
    isRevision: Boolean
    "Whether this page is sticky"
    isSticky: Boolean!
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "Whether the pings are open or closed for this particular post."
    pingStatus: String
    "URLs that have been pinged."
    pinged: [String]
    "Connection between the post type and the postFormat type"
    postFormats(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PostToPostFormatConnectionWhereArgs
    ): PostToPostFormatConnection
    "The id field matches the WP_Post->ID field."
    postId: Int! @deprecated(reason: "Deprecated in favor of the databaseId field")
    "Connection between the post type and the post type"
    preview: PostToPreviewConnectionEdge
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "Related Object"
    relatedPosts: [Post]
    "If the current node is a revision, this field exposes the node this is a revision of. Returns null if the node is not a revision of another node."
    revisionOf: NodeWithRevisionsToContentNodeConnectionEdge
    "Connection between the post type and the post type"
    revisions(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PostToRevisionConnectionWhereArgs
    ): PostToRevisionConnection
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "Connection between the post type and the tag type"
    tags(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PostToTagConnectionWhereArgs
    ): PostToTagConnection
    "The template assigned to a node of content"
    template: ContentTemplate
    "Connection between the post type and the TermNode type"
    terms(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PostToTermNodeConnectionWhereArgs
    ): PostToTermNodeConnection
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "URLs queued to be pinged."
    toPing: [String]
    "Added to the GraphQL Schema because the ACF Field Group "Tutorial Manager" was set to Show in GraphQL."
    tutorialManager: Post_Tutorialmanager
    "The unique resource identifier path"
    uri: String
}

"The postFormat type"
type PostFormat implements DatabaseIdentifier & MenuItemLinkable & Node & TermNode & UniformResourceIdentifiable {
    "Connection between the postFormat type and the ContentNode type"
    contentNodes(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PostFormatToContentNodeConnectionWhereArgs
    ): PostFormatToContentNodeConnection
    "The number of objects connected to the object"
    count: Int
    "The unique resource identifier path"
    databaseId: Int!
    "The description of the object"
    description: String
    "Connection between the TermNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedScriptConnection
    "Connection between the TermNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedStylesheetConnection
    "The unique resource identifier path"
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The link to the term"
    link: String
    "The human friendly name of the object."
    name: String
    "The id field matches the WP_Post->ID field."
    postFormatId: Int @deprecated(reason: "Deprecated in favor of databaseId")
    "Connection between the postFormat type and the post type"
    posts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PostFormatToPostConnectionWhereArgs
    ): PostFormatToPostConnection
    "Connection between the postFormat type and the Product type"
    products(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: PostFormatToProductConnectionWhereArgs
    ): PostFormatToProductConnection
    "The Yoast SEO data of the Formats taxonomy."
    seo: TaxonomySEO
    "An alphanumeric identifier for the object unique to its type."
    slug: String
    "Connection between the postFormat type and the Taxonomy type"
    taxonomy: PostFormatToTaxonomyConnectionEdge
    "The name of the taxonomy that the object is associated with"
    taxonomyName: String
    "The ID of the term group that this term object belongs to"
    termGroupId: Int
    "The taxonomy ID that the object is associated with"
    termTaxonomyId: Int
    "The unique resource identifier path"
    uri: String
}

"Connection between the postFormat type and the ContentNode type"
type PostFormatToContentNodeConnection {
    "Edges for the PostFormatToContentNodeConnection connection"
    edges: [PostFormatToContentNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PostFormatToContentNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentNode
}

"Connection between the postFormat type and the post type"
type PostFormatToPostConnection {
    "Edges for the PostFormatToPostConnection connection"
    edges: [PostFormatToPostConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Post]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PostFormatToPostConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Post
}

"Connection between the postFormat type and the Product type"
type PostFormatToProductConnection {
    "Edges for the PostFormatToProductConnection connection"
    edges: [PostFormatToProductConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Product]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PostFormatToProductConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Product
}

"Connection between the postFormat type and the Taxonomy type"
type PostFormatToTaxonomyConnectionEdge {
    "The node of the connection, without the edges"
    node: Taxonomy
}

"Connection between the post type and the category type"
type PostToCategoryConnection {
    "Edges for the PostToCategoryConnection connection"
    edges: [PostToCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Category]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PostToCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary category"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: Category
}

"Connection between the post type and the Comment type"
type PostToCommentConnection {
    "Edges for the PostToCommentConnection connection"
    edges: [PostToCommentConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Comment]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PostToCommentConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Comment
}

"Connection between the post type and the postFormat type"
type PostToPostFormatConnection {
    "Edges for the PostToPostFormatConnection connection"
    edges: [PostToPostFormatConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [PostFormat]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PostToPostFormatConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary post_format"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: PostFormat
}

"Connection between the post type and the post type"
type PostToPreviewConnectionEdge {
    "The node of the connection, without the edges"
    node: Post
}

"Connection between the post type and the post type"
type PostToRevisionConnection {
    "Edges for the postToRevisionConnection connection"
    edges: [PostToRevisionConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Post]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PostToRevisionConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Post
}

"Connection between the post type and the tag type"
type PostToTagConnection {
    "Edges for the PostToTagConnection connection"
    edges: [PostToTagConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Tag]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PostToTagConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary post_tag"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: Tag
}

"Connection between the post type and the TermNode type"
type PostToTermNodeConnection {
    "Edges for the PostToTermNodeConnection connection"
    edges: [PostToTermNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [TermNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type PostToTermNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: TermNode
}

"Details for labels of the PostType"
type PostTypeLabelDetails {
    "Default is ‘Add New’ for both hierarchical and non-hierarchical types."
    addNew: String
    "Label for adding a new singular item."
    addNewItem: String
    "Label to signify all items in a submenu link."
    allItems: String
    "Label for archives in nav menus"
    archives: String
    "Label for the attributes meta box."
    attributes: String
    "Label for editing a singular item."
    editItem: String
    "Label for the Featured Image meta box title."
    featuredImage: String
    "Label for the table views hidden heading."
    filterItemsList: String
    "Label for the media frame button."
    insertIntoItem: String
    "Label for the table hidden heading."
    itemsList: String
    "Label for the table pagination hidden heading."
    itemsListNavigation: String
    "Label for the menu name."
    menuName: String
    "General name for the post type, usually plural."
    name: String
    "Label for the new item page title."
    newItem: String
    "Label used when no items are found."
    notFound: String
    "Label used when no items are in the trash."
    notFoundInTrash: String
    "Label used to prefix parents of hierarchical items."
    parentItemColon: String
    "Label for removing the featured image."
    removeFeaturedImage: String
    "Label for searching plural items."
    searchItems: String
    "Label for setting the featured image."
    setFeaturedImage: String
    "Name for one object of this post type."
    singularName: String
    "Label for the media frame filter."
    uploadedToThisItem: String
    "Label in the media frame for using a featured image."
    useFeaturedImage: String
    "Label for viewing a singular item."
    viewItem: String
    "Label for viewing post type archives."
    viewItems: String
}

type PostTypeSEO {
    breadcrumbs: [SEOPostTypeBreadcrumbs]
    canonical: String
    cornerstone: Boolean
    focuskw: String
    fullHead: String
    metaDesc: String
    metaKeywords: String
    metaRobotsNofollow: String
    metaRobotsNoindex: String
    opengraphAuthor: String
    opengraphDescription: String
    opengraphImage: MediaItem
    opengraphModifiedTime: String
    opengraphPublishedTime: String
    opengraphPublisher: String
    opengraphSiteName: String
    opengraphTitle: String
    opengraphType: String
    opengraphUrl: String
    readingTime: Float
    schema: SEOPostTypeSchema
    "Yoast SEO Schema"
    schemaDetails: String
    title: String
    twitterDescription: String
    twitterImage: MediaItem
    twitterTitle: String
}

"Field Group"
type Post_Etsocialnav implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Add an image that is optimized for maximum exposure on Pinterest. We recommend using an image that is formatted in a 2:3 aspect ratio like 735x1102."
    pinterestImage: MediaItem
    pinterestMeta: Post_Etsocialnav_PinterestMeta
}

"Field Group"
type Post_Etsocialnav_PinterestMeta implements AcfFieldGroup {
    "Craft a customized description that will be used when this post is shared on Pinterest. Leave this blank to use the title of the post. 140 Character Limit!"
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type Post_Tutorialmanager implements AcfFieldGroup {
    "Select Freebies included in the tutorial that are located in the Tuesday Tribe Resource Library"
    downloads: [Post_Tutorialmanager_Downloads]
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Add post excerpt here. The part above the Read Me dotted line."
    postExcerpt: String
    "Short Summary of the tutorial in 280 characters or less"
    quickSummary: String
    "Extra Resources in the tutorial that need to be clickable - ie courses, free PDFS, or paid product links"
    resources: [Post_Tutorialmanager_Resources]
    youtube: Post_Tutorialmanager_Youtube
}

"Group within the flex field"
type Post_Tutorialmanager_Resources_ColorSwatch implements AcfFieldGroup {
    colorSwatch: Post_Tutorialmanager_Resources_ColorSwatch_ColorSwatch
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type Post_Tutorialmanager_Resources_ColorSwatch_ColorSwatch implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    url: String
}

"Group within the flex field"
type Post_Tutorialmanager_Resources_Course implements AcfFieldGroup {
    course: Post_Tutorialmanager_Resources_Course_Course
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Group within the flex field"
type Post_Tutorialmanager_Resources_Download implements AcfFieldGroup {
    download: Post_Tutorialmanager_Resources_Download_Download
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type Post_Tutorialmanager_Resources_Download_Download implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    url: String
}

"Group within the flex field"
type Post_Tutorialmanager_Resources_Link implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    link: Post_Tutorialmanager_Resources_Link_Link
}

"Field Group"
type Post_Tutorialmanager_Resources_Link_Link implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    url: String
}

"Group within the flex field"
type Post_Tutorialmanager_Resources_PaidProduct implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    product: Post_Tutorialmanager_Resources_PaidProduct_Product
}

"Field Group"
type Post_Tutorialmanager_Youtube implements AcfFieldGroup {
    addVideoMetadata: Boolean
    "Duration of the video. Example 1 min 38 seconds should be entered in as 1:38"
    duration: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    id: String
    "Add Video Meta Data to the page"
    videoObject: Post_Tutorialmanager_Youtube_VideoObject
}

"Field Group"
type Post_Tutorialmanager_Youtube_VideoObject implements AcfFieldGroup {
    clipElements: [Post_Tutorialmanager_Youtube_VideoObject_clipElements]
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    "If the video doesn't have chapters, use this method as an alternate way."
    potentialActions: [Post_Tutorialmanager_Youtube_VideoObject_potentialActions]
    "Grab the URL of the highest rez thumbnail possible"
    thumbnailUrl: String
    "Video publish date"
    uploadDate: String
}

"Field Group"
type Post_Tutorialmanager_Youtube_VideoObject_clipElements implements AcfFieldGroup {
    "Ex: 1 min 32 sec = 1:32"
    endOffset: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    "Ex: 1 min 32 sec = 1:32"
    startOffset: String
}

"Field Group"
type Post_Tutorialmanager_Youtube_VideoObject_potentialActions implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    "Ex: 1 min 38 seconds should be entered in as 1:38"
    startOffset: String
}

"PrettyLink Object"
type PrettyLinkType {
    "PrettyLink Time Stamp"
    created_at: String
    "PrettyLink Description Field"
    description: String
    "PrettyLink Group ID"
    group_id: String
    "PrettyLink database ID"
    id: String
    "PrettyLink CPT ID"
    link_cpt_id: String
    "PrettyLink Status"
    link_status: String
    "PrettyLink Name Field"
    name: String
    "NoFollow no index for http redirect header"
    nofollow: String
    "Pass params from this link to target URL"
    param_forwarding: String
    "PrettyLink Slug Field"
    param_struct: String
    "PrettyLink New Target Url"
    pretty_url: String
    "PrettyLink Redirect Code"
    redirect_type: String
    "PrettyLink Slug Field"
    slug: String
    "PrettyLink Sponsor"
    sponsored: String
    "PrettyLink Click Tracking"
    track_me: String
    "PrettyLink Update Time Stamp"
    updated_at: String
    "PrettyLink new url Field"
    url: String
}

"The Product type"
type Product implements ContentNode & DatabaseIdentifier & MenuItemLinkable & Node & NodeWithFeaturedImage & NodeWithTemplate & NodeWithTitle & UniformResourceIdentifiable {
    "Connection between the Product type and the category type"
    categories(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ProductToCategoryConnectionWhereArgs
    ): ProductToCategoryConnection
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The unique resource identifier path"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "Connection between the NodeWithFeaturedImage type and the MediaItem type"
    featuredImage: NodeWithFeaturedImageToMediaItemConnectionEdge
    "The database identifier for the featured image node assigned to the content node"
    featuredImageDatabaseId: Int
    "Globally unique ID of the featured image assigned to the node"
    featuredImageId: ID
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The globally unique identifier of the product object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "Connection between the Product type and the postFormat type"
    postFormats(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ProductToPostFormatConnectionWhereArgs
    ): ProductToPostFormatConnection
    "Connection between the Product type and the Product type"
    preview: ProductToPreviewConnectionEdge
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "Added to the GraphQL Schema because the ACF Field Group "Product" was set to Show in GraphQL."
    productDetails: Product_Productdetails
    "The id field matches the WP_Post->ID field."
    productId: Int! @deprecated(reason: "Deprecated in favor of the databaseId field")
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "The template assigned to a node of content"
    template: ContentTemplate
    "Connection between the Product type and the TermNode type"
    terms(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ProductToTermNodeConnectionWhereArgs
    ): ProductToTermNodeConnection
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "Added to the GraphQL Schema because the ACF Field Group "Tutorial Manager" was set to Show in GraphQL."
    tutorialManager: Product_Tutorialmanager
    "The unique resource identifier path"
    uri: String
}

"Connection between the Product type and the category type"
type ProductToCategoryConnection {
    "Edges for the ProductToCategoryConnection connection"
    edges: [ProductToCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Category]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ProductToCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary category"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: Category
}

"Connection between the Product type and the postFormat type"
type ProductToPostFormatConnection {
    "Edges for the ProductToPostFormatConnection connection"
    edges: [ProductToPostFormatConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [PostFormat]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ProductToPostFormatConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary post_format"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: PostFormat
}

"Connection between the Product type and the Product type"
type ProductToPreviewConnectionEdge {
    "The node of the connection, without the edges"
    node: Product
}

"Connection between the Product type and the TermNode type"
type ProductToTermNodeConnection {
    "Edges for the ProductToTermNodeConnection connection"
    edges: [ProductToTermNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [TermNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ProductToTermNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: TermNode
}

"Field Group"
type Product_Productdetails implements AcfFieldGroup {
    extendedLicenseUrl: String
    extendedPrice: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    font: Product_Productdetails_Font
    "This is the name of the css file. Example: tuesday.css - the name would be tuesday."
    fontName: String
    fontStyles: [Product_Productdetails_fontStyles]
    "Add Gumroad Url"
    gumroadLink: String
    hasExtendedPrice: Boolean
    hasFontPreview: Boolean
    "Add Licenses here"
    licences: [Product_Productdetails_licences]
    "Add Product Price"
    price: String
    productContent: Product_Productdetails_ProductContent
    "Add Youtube link here"
    youtube: Product_Productdetails_Youtube
    "Add Youtube link here"
    youtubeLink: String
}

"Field Group"
type Product_Productdetails_Font implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
}

"Field Group"
type Product_Productdetails_ProductContent implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Image size must be 1400x1049"
    productfeatureimage: MediaItem
    subtitle: String
}

"Field Group"
type Product_Productdetails_Youtube implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    url: String
}

"Field Group"
type Product_Productdetails_fontStyles implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    style: String
}

"Field Group"
type Product_Productdetails_licences implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    licenseType: String
    price: Float
    url: String
}

"Field Group"
type Product_Tutorialmanager implements AcfFieldGroup {
    "Select Freebies included in the tutorial that are located in the Tuesday Tribe Resource Library"
    downloads: [Product_Tutorialmanager_Downloads]
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Add post excerpt here. The part above the Read Me dotted line."
    postExcerpt: String
    "Short Summary of the tutorial in 280 characters or less"
    quickSummary: String
    "Extra Resources in the tutorial that need to be clickable - ie courses, free PDFS, or paid product links"
    resources: [Product_Tutorialmanager_Resources]
    youtube: Product_Tutorialmanager_Youtube
}

"Group within the flex field"
type Product_Tutorialmanager_Resources_ColorSwatch implements AcfFieldGroup {
    colorSwatch: Product_Tutorialmanager_Resources_ColorSwatch_ColorSwatch
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type Product_Tutorialmanager_Resources_ColorSwatch_ColorSwatch implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    url: String
}

"Group within the flex field"
type Product_Tutorialmanager_Resources_Course implements AcfFieldGroup {
    course: Product_Tutorialmanager_Resources_Course_Course
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Group within the flex field"
type Product_Tutorialmanager_Resources_Download implements AcfFieldGroup {
    download: Product_Tutorialmanager_Resources_Download_Download
    "The name of the ACF Field Group"
    fieldGroupName: String
}

"Field Group"
type Product_Tutorialmanager_Resources_Download_Download implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    url: String
}

"Group within the flex field"
type Product_Tutorialmanager_Resources_Link implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    link: Product_Tutorialmanager_Resources_Link_Link
}

"Field Group"
type Product_Tutorialmanager_Resources_Link_Link implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    url: String
}

"Group within the flex field"
type Product_Tutorialmanager_Resources_PaidProduct implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    product: Product_Tutorialmanager_Resources_PaidProduct_Product
}

"Field Group"
type Product_Tutorialmanager_Youtube implements AcfFieldGroup {
    addVideoMetadata: Boolean
    "Duration of the video. Example 1 min 38 seconds should be entered in as 1:38"
    duration: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    id: String
    "Add Video Meta Data to the page"
    videoObject: Product_Tutorialmanager_Youtube_VideoObject
}

"Field Group"
type Product_Tutorialmanager_Youtube_VideoObject implements AcfFieldGroup {
    clipElements: [Product_Tutorialmanager_Youtube_VideoObject_clipElements]
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    "If the video doesn't have chapters, use this method as an alternate way."
    potentialActions: [Product_Tutorialmanager_Youtube_VideoObject_potentialActions]
    "Grab the URL of the highest rez thumbnail possible"
    thumbnailUrl: String
    "Video publish date"
    uploadDate: String
}

"Field Group"
type Product_Tutorialmanager_Youtube_VideoObject_clipElements implements AcfFieldGroup {
    "Ex: 1 min 32 sec = 1:32"
    endOffset: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    "Ex: 1 min 32 sec = 1:32"
    startOffset: String
}

"Field Group"
type Product_Tutorialmanager_Youtube_VideoObject_potentialActions implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    name: String
    "Ex: 1 min 38 seconds should be entered in as 1:38"
    startOffset: String
}

"The reading setting type"
type ReadingSettings {
    "Blog pages show at most."
    postsPerPage: Int
}

"The payload for the refreshJwtAuthToken mutation"
type RefreshJwtAuthTokenPayload {
    "JWT Token that can be used in future requests for Authentication"
    authToken: String
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
}

"The payload for the registerUser mutation"
type RegisterUserPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The User object mutation type."
    user: User
}

"The payload for the removeFromWishlist mutation"
type RemoveFromWishlistPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Description of the error"
    error: String
    "The Product id that was deleted"
    productId: Int
    "True if the product is removed, false otherwise"
    removed: Boolean
    "The Product ids in the wishlist"
    wishlistProductIds: [Int]
}

"The payload for the resetUserPassword mutation"
type ResetUserPasswordPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The User object mutation type."
    user: User
}

"The ResourceLibrary type"
type ResourceLibrary implements ContentNode & DatabaseIdentifier & MenuItemLinkable & Node & NodeWithFeaturedImage & NodeWithTemplate & NodeWithTitle & UniformResourceIdentifiable {
    "Connection between the ResourceLibrary type and the category type"
    categories(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ResourceLibraryToCategoryConnectionWhereArgs
    ): ResourceLibraryToCategoryConnection
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The unique resource identifier path"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "Connection between the NodeWithFeaturedImage type and the MediaItem type"
    featuredImage: NodeWithFeaturedImageToMediaItemConnectionEdge
    "The database identifier for the featured image node assigned to the content node"
    featuredImageDatabaseId: Int
    "Globally unique ID of the featured image assigned to the node"
    featuredImageId: ID
    "Added to the GraphQL Schema because the ACF Field Group "Resource Library Freebie" was set to Show in GraphQL."
    freebie: ResourceLibrary_Freebie
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The globally unique identifier of the et_freebie object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "Connection between the ResourceLibrary type and the ResourceLibrary type"
    preview: ResourceLibraryToPreviewConnectionEdge
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "The id field matches the WP_Post->ID field."
    resourceLibraryId: Int! @deprecated(reason: "Deprecated in favor of the databaseId field")
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "Connection between the ResourceLibrary type and the subCategory type"
    subCategories(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ResourceLibraryToSubCategoryConnectionWhereArgs
    ): ResourceLibraryToSubCategoryConnection
    "Connection between the ResourceLibrary type and the tag type"
    tags(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ResourceLibraryToTagConnectionWhereArgs
    ): ResourceLibraryToTagConnection
    "The template assigned to a node of content"
    template: ContentTemplate
    "Connection between the ResourceLibrary type and the TermNode type"
    terms(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ResourceLibraryToTermNodeConnectionWhereArgs
    ): ResourceLibraryToTermNodeConnection
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "The unique resource identifier path"
    uri: String
}

"Connection between the ResourceLibrary type and the category type"
type ResourceLibraryToCategoryConnection {
    "Edges for the ResourceLibraryToCategoryConnection connection"
    edges: [ResourceLibraryToCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Category]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ResourceLibraryToCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary category"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: Category
}

"Connection between the ResourceLibrary type and the ResourceLibrary type"
type ResourceLibraryToPreviewConnectionEdge {
    "The node of the connection, without the edges"
    node: ResourceLibrary
}

"Connection between the ResourceLibrary type and the subCategory type"
type ResourceLibraryToSubCategoryConnection {
    "Edges for the ResourceLibraryToSubCategoryConnection connection"
    edges: [ResourceLibraryToSubCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [SubCategory]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ResourceLibraryToSubCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary subcategory"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: SubCategory
}

"Connection between the ResourceLibrary type and the tag type"
type ResourceLibraryToTagConnection {
    "Edges for the ResourceLibraryToTagConnection connection"
    edges: [ResourceLibraryToTagConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Tag]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ResourceLibraryToTagConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary post_tag"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: Tag
}

"Connection between the ResourceLibrary type and the TermNode type"
type ResourceLibraryToTermNodeConnection {
    "Edges for the ResourceLibraryToTermNodeConnection connection"
    edges: [ResourceLibraryToTermNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [TermNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ResourceLibraryToTermNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: TermNode
}

"Field Group"
type ResourceLibrary_Freebie implements AcfFieldGroup {
    downloadLink: String
    excerpt: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Has a paid product version?"
    licenseRequired: Boolean
    product: ResourceLibrary_Freebie_Product
}

"The payload for the restoreComment mutation"
type RestoreCommentPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The restored comment object"
    comment: Comment
    "The ID of the restored comment"
    restoredId: ID
}

"The root mutation"
type RootMutation {
    "The payload for the addToWishlist mutation"
    addToWishlist(
        "Input for the addToWishlist mutation"
        input: AddToWishlistInput!
    ): AddToWishlistPayload
    "The payload for the createCategory mutation"
    createCategory(
        "Input for the createCategory mutation"
        input: CreateCategoryInput!
    ): CreateCategoryPayload
    "The payload for the createComment mutation"
    createComment(
        "Input for the createComment mutation"
        input: CreateCommentInput!
    ): CreateCommentPayload
    "The payload for the createCourse mutation"
    createCourse(
        "Input for the createCourse mutation"
        input: CreateCourseInput!
    ): CreateCoursePayload
    "The payload for the createDownloadFreebie mutation"
    createDownloadFreebie(
        "Input for the createDownloadFreebie mutation"
        input: CreateDownloadFreebieInput!
    ): CreateDownloadFreebiePayload
    "The payload for the createDownloadGrid mutation"
    createDownloadGrid(
        "Input for the createDownloadGrid mutation"
        input: CreateDownloadGridInput!
    ): CreateDownloadGridPayload
    "The payload for the createMediaItem mutation"
    createMediaItem(
        "Input for the createMediaItem mutation"
        input: CreateMediaItemInput!
    ): CreateMediaItemPayload
    "The payload for the createPage mutation"
    createPage(
        "Input for the createPage mutation"
        input: CreatePageInput!
    ): CreatePagePayload
    "The payload for the createPost mutation"
    createPost(
        "Input for the createPost mutation"
        input: CreatePostInput!
    ): CreatePostPayload
    "The payload for the createPostFormat mutation"
    createPostFormat(
        "Input for the createPostFormat mutation"
        input: CreatePostFormatInput!
    ): CreatePostFormatPayload
    "The payload for the createProduct mutation"
    createProduct(
        "Input for the createProduct mutation"
        input: CreateProductInput!
    ): CreateProductPayload
    "The payload for the createResourceLibrary mutation"
    createResourceLibrary(
        "Input for the createResourceLibrary mutation"
        input: CreateResourceLibraryInput!
    ): CreateResourceLibraryPayload
    "The payload for the createSubCategory mutation"
    createSubCategory(
        "Input for the createSubCategory mutation"
        input: CreateSubCategoryInput!
    ): CreateSubCategoryPayload
    "The payload for the createTag mutation"
    createTag(
        "Input for the createTag mutation"
        input: CreateTagInput!
    ): CreateTagPayload
    "The payload for the createThingILove mutation"
    createThingILove(
        "Input for the createThingILove mutation"
        input: CreateThingILoveInput!
    ): CreateThingILovePayload
    "The payload for the createUser mutation"
    createUser(
        "Input for the createUser mutation"
        input: CreateUserInput!
    ): CreateUserPayload
    "The payload for the deleteCategory mutation"
    deleteCategory(
        "Input for the deleteCategory mutation"
        input: DeleteCategoryInput!
    ): DeleteCategoryPayload
    "The payload for the deleteComment mutation"
    deleteComment(
        "Input for the deleteComment mutation"
        input: DeleteCommentInput!
    ): DeleteCommentPayload
    "The payload for the deleteCourse mutation"
    deleteCourse(
        "Input for the deleteCourse mutation"
        input: DeleteCourseInput!
    ): DeleteCoursePayload
    "The payload for the deleteDownloadFreebie mutation"
    deleteDownloadFreebie(
        "Input for the deleteDownloadFreebie mutation"
        input: DeleteDownloadFreebieInput!
    ): DeleteDownloadFreebiePayload
    "The payload for the deleteDownloadGrid mutation"
    deleteDownloadGrid(
        "Input for the deleteDownloadGrid mutation"
        input: DeleteDownloadGridInput!
    ): DeleteDownloadGridPayload
    "The payload for the deleteMediaItem mutation"
    deleteMediaItem(
        "Input for the deleteMediaItem mutation"
        input: DeleteMediaItemInput!
    ): DeleteMediaItemPayload
    "The payload for the deletePage mutation"
    deletePage(
        "Input for the deletePage mutation"
        input: DeletePageInput!
    ): DeletePagePayload
    "The payload for the deletePost mutation"
    deletePost(
        "Input for the deletePost mutation"
        input: DeletePostInput!
    ): DeletePostPayload
    "The payload for the deletePostFormat mutation"
    deletePostFormat(
        "Input for the deletePostFormat mutation"
        input: DeletePostFormatInput!
    ): DeletePostFormatPayload
    "The payload for the deleteProduct mutation"
    deleteProduct(
        "Input for the deleteProduct mutation"
        input: DeleteProductInput!
    ): DeleteProductPayload
    "The payload for the deleteResourceLibrary mutation"
    deleteResourceLibrary(
        "Input for the deleteResourceLibrary mutation"
        input: DeleteResourceLibraryInput!
    ): DeleteResourceLibraryPayload
    "The payload for the deleteSubCategory mutation"
    deleteSubCategory(
        "Input for the deleteSubCategory mutation"
        input: DeleteSubCategoryInput!
    ): DeleteSubCategoryPayload
    "The payload for the deleteTag mutation"
    deleteTag(
        "Input for the deleteTag mutation"
        input: DeleteTagInput!
    ): DeleteTagPayload
    "The payload for the deleteThingILove mutation"
    deleteThingILove(
        "Input for the deleteThingILove mutation"
        input: DeleteThingILoveInput!
    ): DeleteThingILovePayload
    "The payload for the deleteUser mutation"
    deleteUser(
        "Input for the deleteUser mutation"
        input: DeleteUserInput!
    ): DeleteUserPayload
    "Increase the count."
    increaseCount(
        "The count to increase"
        count: Int
    ): Int
    "The payload for the login mutation"
    login(
        "Input for the login mutation"
        input: LoginInput!
    ): LoginPayload
    "The payload for the loginWithCookies mutation"
    loginWithCookies(
        "Input for the loginWithCookies mutation"
        input: LoginWithCookiesInput!
    ): LoginWithCookiesPayload
    "The payload for the logout mutation"
    logout(
        "Input for the logout mutation"
        input: LogoutInput!
    ): LogoutPayload
    "The payload for the refreshJwtAuthToken mutation"
    refreshJwtAuthToken(
        "Input for the refreshJwtAuthToken mutation"
        input: RefreshJwtAuthTokenInput!
    ): RefreshJwtAuthTokenPayload
    "The payload for the registerUser mutation"
    registerUser(
        "Input for the registerUser mutation"
        input: RegisterUserInput!
    ): RegisterUserPayload
    "The payload for the removeFromWishlist mutation"
    removeFromWishlist(
        "Input for the removeFromWishlist mutation"
        input: RemoveFromWishlistInput!
    ): RemoveFromWishlistPayload
    "The payload for the resetUserPassword mutation"
    resetUserPassword(
        "Input for the resetUserPassword mutation"
        input: ResetUserPasswordInput!
    ): ResetUserPasswordPayload
    "The payload for the restoreComment mutation"
    restoreComment(
        "Input for the restoreComment mutation"
        input: RestoreCommentInput!
    ): RestoreCommentPayload
    "The payload for the sendEmail mutation"
    sendEmail(
        "Input for the sendEmail mutation"
        input: SendEmailInput!
    ): SendEmailPayload
    "The payload for the sendPasswordResetEmail mutation"
    sendPasswordResetEmail(
        "Input for the sendPasswordResetEmail mutation"
        input: SendPasswordResetEmailInput!
    ): SendPasswordResetEmailPayload
    "The payload for the UpdateCategory mutation"
    updateCategory(
        "Input for the UpdateCategory mutation"
        input: UpdateCategoryInput!
    ): UpdateCategoryPayload
    "The payload for the updateComment mutation"
    updateComment(
        "Input for the updateComment mutation"
        input: UpdateCommentInput!
    ): UpdateCommentPayload
    "The payload for the updateCourse mutation"
    updateCourse(
        "Input for the updateCourse mutation"
        input: UpdateCourseInput!
    ): UpdateCoursePayload
    "The payload for the updateDownloadFreebie mutation"
    updateDownloadFreebie(
        "Input for the updateDownloadFreebie mutation"
        input: UpdateDownloadFreebieInput!
    ): UpdateDownloadFreebiePayload
    "The payload for the updateDownloadGrid mutation"
    updateDownloadGrid(
        "Input for the updateDownloadGrid mutation"
        input: UpdateDownloadGridInput!
    ): UpdateDownloadGridPayload
    "The payload for the updateMediaItem mutation"
    updateMediaItem(
        "Input for the updateMediaItem mutation"
        input: UpdateMediaItemInput!
    ): UpdateMediaItemPayload
    "The payload for the updatePage mutation"
    updatePage(
        "Input for the updatePage mutation"
        input: UpdatePageInput!
    ): UpdatePagePayload
    "The payload for the updatePost mutation"
    updatePost(
        "Input for the updatePost mutation"
        input: UpdatePostInput!
    ): UpdatePostPayload
    "The payload for the UpdatePostFormat mutation"
    updatePostFormat(
        "Input for the UpdatePostFormat mutation"
        input: UpdatePostFormatInput!
    ): UpdatePostFormatPayload
    "The payload for the updateProduct mutation"
    updateProduct(
        "Input for the updateProduct mutation"
        input: UpdateProductInput!
    ): UpdateProductPayload
    "The payload for the updateResourceLibrary mutation"
    updateResourceLibrary(
        "Input for the updateResourceLibrary mutation"
        input: UpdateResourceLibraryInput!
    ): UpdateResourceLibraryPayload
    "The payload for the updateSettings mutation"
    updateSettings(
        "Input for the updateSettings mutation"
        input: UpdateSettingsInput!
    ): UpdateSettingsPayload
    "The payload for the UpdateSubCategory mutation"
    updateSubCategory(
        "Input for the UpdateSubCategory mutation"
        input: UpdateSubCategoryInput!
    ): UpdateSubCategoryPayload
    "The payload for the UpdateTag mutation"
    updateTag(
        "Input for the UpdateTag mutation"
        input: UpdateTagInput!
    ): UpdateTagPayload
    "The payload for the updateThingILove mutation"
    updateThingILove(
        "Input for the updateThingILove mutation"
        input: UpdateThingILoveInput!
    ): UpdateThingILovePayload
    "The payload for the updateUser mutation"
    updateUser(
        "Input for the updateUser mutation"
        input: UpdateUserInput!
    ): UpdateUserPayload
}

"The root entry point into the Graph"
type RootQuery {
    "Entry point to get all settings for the site"
    allSettings: Settings
    "Connection between the RootQuery type and the category type"
    categories(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToCategoryConnectionWhereArgs
    ): RootQueryToCategoryConnection
    "A 0bject"
    category(
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: CategoryIdType
    ): Category
    "Returns a Comment"
    comment(
        "Unique identifier for the comment node."
        id: ID!
    ): Comment
    "Connection between the RootQuery type and the Comment type"
    comments(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToCommentConnectionWhereArgs
    ): RootQueryToCommentConnection
    "A node used to manage content"
    contentNode(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The content type the node is used for. Required when idType is set to \"name\" or \"slug\""
        contentType: ContentTypeEnum,
        "Unique identifier for the content node."
        id: ID!,
        "Type of unique identifier to fetch a content node by. Default is Global ID"
        idType: ContentNodeIdTypeEnum
    ): ContentNode
    "Connection between the RootQuery type and the ContentNode type"
    contentNodes(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToContentNodeConnectionWhereArgs
    ): RootQueryToContentNodeConnection
    "Fetch a Content Type node by unique Identifier"
    contentType(
        "Unique Identifier for the Content Type node."
        id: ID!,
        "Type of unique identifier to fetch a content type by. Default is Global ID"
        idType: ContentTypeIdTypeEnum
    ): ContentType
    "Connection between the RootQuery type and the ContentType type"
    contentTypes(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): RootQueryToContentTypeConnection
    "An object of the Course Type. "
    course(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: CourseIdType
    ): Course
    "A Course object"
    courseBy(
        "Get the Course by its database ID"
        courseId: Int,
        "Get the object by its global ID"
        id: ID,
        "Get the Course by its slug (only available for non-hierarchical types)"
        slug: String,
        "Get the Course by its uri"
        uri: String
    ): Course @deprecated(reason: "Deprecated in favor of using the single entry point for this type with ID and IDType fields. For example, instead of postBy( id: "" ), use post(id: "" idType: "")")
    "Connection between the RootQuery type and the Course type"
    courses(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToCourseConnectionWhereArgs
    ): RootQueryToCourseConnection
    "Get all the tags by custom post type"
    cptTags(postType: String): [Cpt_tag]
    "Fields of the 'DiscussionSettings' settings group"
    discussionSettings: DiscussionSettings
    "An object of the downloadFreebie Type. Add Download links here"
    downloadFreebie(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: DownloadFreebieIdType
    ): DownloadFreebie
    "A downloadFreebie object"
    downloadFreebieBy(
        "Get the downloadFreebie by its database ID"
        downloadFreebieId: Int,
        "Get the object by its global ID"
        id: ID,
        "Get the downloadFreebie by its slug (only available for non-hierarchical types)"
        slug: String,
        "Get the downloadFreebie by its uri"
        uri: String
    ): DownloadFreebie @deprecated(reason: "Deprecated in favor of using the single entry point for this type with ID and IDType fields. For example, instead of postBy( id: "" ), use post(id: "" idType: "")")
    "Connection between the RootQuery type and the downloadFreebie type"
    downloadFreebies(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToDownloadFreebieConnectionWhereArgs
    ): RootQueryToDownloadFreebieConnection
    "An object of the DownloadGrid Type. Add New Grid"
    downloadGrid(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: DownloadGridIdType
    ): DownloadGrid
    "A DownloadGrid object"
    downloadGridBy(
        "Get the DownloadGrid by its database ID"
        downloadGridId: Int,
        "Get the object by its global ID"
        id: ID,
        "Get the DownloadGrid by its slug (only available for non-hierarchical types)"
        slug: String,
        "Get the DownloadGrid by its uri"
        uri: String
    ): DownloadGrid @deprecated(reason: "Deprecated in favor of using the single entry point for this type with ID and IDType fields. For example, instead of postBy( id: "" ), use post(id: "" idType: "")")
    "Connection between the RootQuery type and the DownloadGrid type"
    downloadGrids(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToDownloadGridConnectionWhereArgs
    ): RootQueryToDownloadGridConnection
    "Fields of the 'GeneralSettings' settings group"
    generalSettings: GeneralSettings
    "Get footer"
    getFooter: HCMSFooter
    "Get header"
    getHeader: HCMSHeader
    "Get all the tags by grid type"
    gridTags(slug: String): [GridTag]
    "An object of the mediaItem Type. "
    mediaItem(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: MediaItemIdType
    ): MediaItem
    "A mediaItem object"
    mediaItemBy(
        "Get the object by its global ID"
        id: ID,
        "Get the mediaItem by its database ID"
        mediaItemId: Int,
        "Get the mediaItem by its slug (only available for non-hierarchical types)"
        slug: String,
        "Get the mediaItem by its uri"
        uri: String
    ): MediaItem @deprecated(reason: "Deprecated in favor of using the single entry point for this type with ID and IDType fields. For example, instead of postBy( id: "" ), use post(id: "" idType: "")")
    "Connection between the RootQuery type and the mediaItem type"
    mediaItems(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToMediaItemConnectionWhereArgs
    ): RootQueryToMediaItemConnection
    "A WordPress navigation menu"
    menu(
        "The globally unique identifier of the menu."
        id: ID!,
        "Type of unique identifier to fetch a menu by. Default is Global ID"
        idType: MenuNodeIdTypeEnum
    ): Menu
    "A WordPress navigation menu item"
    menuItem(
        "The globally unique identifier of the menu item."
        id: ID!,
        "Type of unique identifier to fetch a menu item by. Default is Global ID"
        idType: MenuItemNodeIdTypeEnum
    ): MenuItem
    "Connection between the RootQuery type and the MenuItem type"
    menuItems(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToMenuItemConnectionWhereArgs
    ): RootQueryToMenuItemConnection
    "Connection between the RootQuery type and the Menu type"
    menus(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToMenuConnectionWhereArgs
    ): RootQueryToMenuConnection
    "Fetches an object given its ID"
    node(
        "The unique identifier of the node"
        id: ID
    ): Node
    "Fetches an object given its Unique Resource Identifier"
    nodeByUri(
        "Unique Resource Identifier in the form of a path or permalink for a node. Ex: \"/hello-world\""
        uri: String!
    ): UniformResourceIdentifiable
    "An object of the page Type. "
    page(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: PageIdType
    ): Page
    "A page object"
    pageBy(
        "Get the object by its global ID"
        id: ID,
        "Get the page by its database ID"
        pageId: Int,
        "Get the page by its uri"
        uri: String
    ): Page @deprecated(reason: "Deprecated in favor of using the single entry point for this type with ID and IDType fields. For example, instead of postBy( id: "" ), use post(id: "" idType: "")")
    "Connection between the RootQuery type and the page type"
    pages(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToPageConnectionWhereArgs
    ): RootQueryToPageConnection
    "A WordPress plugin"
    plugin(
        "The globally unique identifier of the plugin."
        id: ID!
    ): Plugin
    "Connection between the RootQuery type and the Plugin type"
    plugins(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToPluginConnectionWhereArgs
    ): RootQueryToPluginConnection
    "An object of the post Type. "
    post(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: PostIdType
    ): Post
    "A post object"
    postBy(
        "Get the object by its global ID"
        id: ID,
        "Get the post by its database ID"
        postId: Int,
        "Get the post by its slug (only available for non-hierarchical types)"
        slug: String,
        "Get the post by its uri"
        uri: String
    ): Post @deprecated(reason: "Deprecated in favor of using the single entry point for this type with ID and IDType fields. For example, instead of postBy( id: "" ), use post(id: "" idType: "")")
    "A 0bject"
    postFormat(
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: PostFormatIdType
    ): PostFormat
    "Connection between the RootQuery type and the postFormat type"
    postFormats(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToPostFormatConnectionWhereArgs
    ): RootQueryToPostFormatConnection
    "Connection between the RootQuery type and the post type"
    posts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToPostConnectionWhereArgs
    ): RootQueryToPostConnection
    "Describe what the field should be used for"
    prettyLinkTypes: [PrettyLinkType]
    "An object of the Product Type. Add Products here"
    product(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: ProductIdType
    ): Product
    "A Product object"
    productBy(
        "Get the object by its global ID"
        id: ID,
        "Get the Product by its database ID"
        productId: Int,
        "Get the Product by its slug (only available for non-hierarchical types)"
        slug: String,
        "Get the Product by its uri"
        uri: String
    ): Product @deprecated(reason: "Deprecated in favor of using the single entry point for this type with ID and IDType fields. For example, instead of postBy( id: "" ), use post(id: "" idType: "")")
    "Connection between the RootQuery type and the Product type"
    products(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToProductConnectionWhereArgs
    ): RootQueryToProductConnection
    "Fields of the 'ReadingSettings' settings group"
    readingSettings: ReadingSettings
    "Connection between the RootQuery type and the EnqueuedScript type"
    registeredScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): RootQueryToEnqueuedScriptConnection
    "Connection between the RootQuery type and the EnqueuedStylesheet type"
    registeredStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): RootQueryToEnqueuedStylesheetConnection
    "Connection between the RootQuery type and the ResourceLibrary type"
    resourceLibraries(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToResourceLibraryConnectionWhereArgs
    ): RootQueryToResourceLibraryConnection
    "An object of the ResourceLibrary Type. "
    resourceLibrary(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: ResourceLibraryIdType
    ): ResourceLibrary
    "A ResourceLibrary object"
    resourceLibraryBy(
        "Get the object by its global ID"
        id: ID,
        "Get the ResourceLibrary by its database ID"
        resourceLibraryId: Int,
        "Get the ResourceLibrary by its slug (only available for non-hierarchical types)"
        slug: String,
        "Get the ResourceLibrary by its uri"
        uri: String
    ): ResourceLibrary @deprecated(reason: "Deprecated in favor of using the single entry point for this type with ID and IDType fields. For example, instead of postBy( id: "" ), use post(id: "" idType: "")")
    "Connection between the RootQuery type and the ContentRevisionUnion type"
    revisions(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToContentRevisionUnionConnectionWhereArgs
    ): RootQueryToContentRevisionUnionConnection
    "Returns seo site data"
    seo: SEOConfig
    "Shipping Zones"
    shippingInfo: ShippingInfo
    "Connection between the RootQuery type and the subCategory type"
    subCategories(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToSubCategoryConnectionWhereArgs
    ): RootQueryToSubCategoryConnection
    "A 0bject"
    subCategory(
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: SubCategoryIdType
    ): SubCategory
    "A 0bject"
    tag(
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: TagIdType
    ): Tag
    "Connection between the RootQuery type and the tag type"
    tags(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToTagConnectionWhereArgs
    ): RootQueryToTagConnection
    "Connection between the RootQuery type and the Taxonomy type"
    taxonomies(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): RootQueryToTaxonomyConnection
    "Fetch a Taxonomy node by unique Identifier"
    taxonomy(
        "Unique Identifier for the Taxonomy node."
        id: ID!,
        "Type of unique identifier to fetch a taxonomy by. Default is Global ID"
        idType: TaxonomyIdTypeEnum
    ): Taxonomy
    "A node in a taxonomy used to group and relate content nodes"
    termNode(
        "Unique identifier for the term node."
        id: ID!,
        "Type of unique identifier to fetch a term node by. Default is Global ID"
        idType: TermNodeIdTypeEnum,
        "The taxonomy of the tern node. Required when idType is set to \"name\" or \"slug\""
        taxonomy: TaxonomyEnum
    ): TermNode
    "Connection between the RootQuery type and the TermNode type"
    terms(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToTermNodeConnectionWhereArgs
    ): RootQueryToTermNodeConnection
    "A Theme object"
    theme(
        "The globally unique identifier of the theme."
        id: ID!
    ): Theme
    "Dashboard options."
    themeOptions: ThemeOptions
    "Connection between the RootQuery type and the Theme type"
    themes(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): RootQueryToThemeConnection
    "An object of the ThingILove Type. "
    thingILove(
        "Whether to return the node as a preview instance"
        asPreview: Boolean,
        "The globally unique identifier of the object."
        id: ID!,
        "Type of unique identifier to fetch by. Default is Global ID"
        idType: ThingILoveIdType
    ): ThingILove
    "A ThingILove object"
    thingILoveBy(
        "Get the object by its global ID"
        id: ID,
        "Get the ThingILove by its slug (only available for non-hierarchical types)"
        slug: String,
        "Get the ThingILove by its database ID"
        thingILoveId: Int,
        "Get the ThingILove by its uri"
        uri: String
    ): ThingILove @deprecated(reason: "Deprecated in favor of using the single entry point for this type with ID and IDType fields. For example, instead of postBy( id: "" ), use post(id: "" idType: "")")
    "Connection between the RootQuery type and the ThingILove type"
    thingsILove(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToThingILoveConnectionWhereArgs
    ): RootQueryToThingILoveConnection
    "Returns a user"
    user(
        "The globally unique identifier of the user."
        id: ID!,
        "Type of unique identifier to fetch a user by. Default is Global ID"
        idType: UserNodeIdTypeEnum
    ): User
    "Returns a user role"
    userRole(
        "The globally unique identifier of the user object."
        id: ID!
    ): UserRole
    "Connection between the RootQuery type and the UserRole type"
    userRoles(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): RootQueryToUserRoleConnection
    "Connection between the RootQuery type and the User type"
    users(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: RootQueryToUserConnectionWhereArgs
    ): RootQueryToUserConnection
    "Returns the current user"
    viewer: User
    "Countries"
    wooCountries: WooCountries
    "States"
    wooStates(countryCode: String): WooStates
    "Fields of the 'WritingSettings' settings group"
    writingSettings: WritingSettings
}

"Connection between the RootQuery type and the category type"
type RootQueryToCategoryConnection {
    "Edges for the RootQueryToCategoryConnection connection"
    edges: [RootQueryToCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Category]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Category
}

"Connection between the RootQuery type and the Comment type"
type RootQueryToCommentConnection {
    "Edges for the RootQueryToCommentConnection connection"
    edges: [RootQueryToCommentConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Comment]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToCommentConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Comment
}

"Connection between the RootQuery type and the ContentNode type"
type RootQueryToContentNodeConnection {
    "Edges for the RootQueryToContentNodeConnection connection"
    edges: [RootQueryToContentNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToContentNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentNode
}

"Connection between the RootQuery type and the ContentRevisionUnion type"
type RootQueryToContentRevisionUnionConnection {
    "Edges for the RootQueryToContentRevisionUnionConnection connection"
    edges: [RootQueryToContentRevisionUnionConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentRevisionUnion]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToContentRevisionUnionConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentRevisionUnion
}

"Connection between the RootQuery type and the ContentType type"
type RootQueryToContentTypeConnection {
    "Edges for the RootQueryToContentTypeConnection connection"
    edges: [RootQueryToContentTypeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentType]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToContentTypeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentType
}

"Connection between the RootQuery type and the Course type"
type RootQueryToCourseConnection {
    "Edges for the RootQueryToCourseConnection connection"
    edges: [RootQueryToCourseConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Course]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToCourseConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Course
}

"Connection between the RootQuery type and the downloadFreebie type"
type RootQueryToDownloadFreebieConnection {
    "Edges for the RootQueryToDownloadFreebieConnection connection"
    edges: [RootQueryToDownloadFreebieConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [DownloadFreebie]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToDownloadFreebieConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: DownloadFreebie
}

"Connection between the RootQuery type and the DownloadGrid type"
type RootQueryToDownloadGridConnection {
    "Edges for the RootQueryToDownloadGridConnection connection"
    edges: [RootQueryToDownloadGridConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [DownloadGrid]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToDownloadGridConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: DownloadGrid
}

"Connection between the RootQuery type and the EnqueuedScript type"
type RootQueryToEnqueuedScriptConnection {
    "Edges for the RootQueryToEnqueuedScriptConnection connection"
    edges: [RootQueryToEnqueuedScriptConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [EnqueuedScript]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToEnqueuedScriptConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: EnqueuedScript
}

"Connection between the RootQuery type and the EnqueuedStylesheet type"
type RootQueryToEnqueuedStylesheetConnection {
    "Edges for the RootQueryToEnqueuedStylesheetConnection connection"
    edges: [RootQueryToEnqueuedStylesheetConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [EnqueuedStylesheet]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToEnqueuedStylesheetConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: EnqueuedStylesheet
}

"Connection between the RootQuery type and the mediaItem type"
type RootQueryToMediaItemConnection {
    "Edges for the RootQueryToMediaItemConnection connection"
    edges: [RootQueryToMediaItemConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [MediaItem]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToMediaItemConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: MediaItem
}

"Connection between the RootQuery type and the Menu type"
type RootQueryToMenuConnection {
    "Edges for the RootQueryToMenuConnection connection"
    edges: [RootQueryToMenuConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Menu]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToMenuConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Menu
}

"Connection between the RootQuery type and the MenuItem type"
type RootQueryToMenuItemConnection {
    "Edges for the RootQueryToMenuItemConnection connection"
    edges: [RootQueryToMenuItemConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [MenuItem]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToMenuItemConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: MenuItem
}

"Connection between the RootQuery type and the page type"
type RootQueryToPageConnection {
    "Edges for the RootQueryToPageConnection connection"
    edges: [RootQueryToPageConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Page]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToPageConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Page
}

"Connection between the RootQuery type and the Plugin type"
type RootQueryToPluginConnection {
    "Edges for the RootQueryToPluginConnection connection"
    edges: [RootQueryToPluginConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Plugin]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToPluginConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Plugin
}

"Connection between the RootQuery type and the post type"
type RootQueryToPostConnection {
    "Edges for the RootQueryToPostConnection connection"
    edges: [RootQueryToPostConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Post]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToPostConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Post
}

"Connection between the RootQuery type and the postFormat type"
type RootQueryToPostFormatConnection {
    "Edges for the RootQueryToPostFormatConnection connection"
    edges: [RootQueryToPostFormatConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [PostFormat]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToPostFormatConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: PostFormat
}

"Connection between the RootQuery type and the Product type"
type RootQueryToProductConnection {
    "Edges for the RootQueryToProductConnection connection"
    edges: [RootQueryToProductConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Product]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToProductConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Product
}

"Connection between the RootQuery type and the ResourceLibrary type"
type RootQueryToResourceLibraryConnection {
    "Edges for the RootQueryToResourceLibraryConnection connection"
    edges: [RootQueryToResourceLibraryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ResourceLibrary]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToResourceLibraryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ResourceLibrary
}

"Connection between the RootQuery type and the subCategory type"
type RootQueryToSubCategoryConnection {
    "Edges for the RootQueryToSubCategoryConnection connection"
    edges: [RootQueryToSubCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [SubCategory]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToSubCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: SubCategory
}

"Connection between the RootQuery type and the tag type"
type RootQueryToTagConnection {
    "Edges for the RootQueryToTagConnection connection"
    edges: [RootQueryToTagConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Tag]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToTagConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Tag
}

"Connection between the RootQuery type and the Taxonomy type"
type RootQueryToTaxonomyConnection {
    "Edges for the RootQueryToTaxonomyConnection connection"
    edges: [RootQueryToTaxonomyConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Taxonomy]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToTaxonomyConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Taxonomy
}

"Connection between the RootQuery type and the TermNode type"
type RootQueryToTermNodeConnection {
    "Edges for the RootQueryToTermNodeConnection connection"
    edges: [RootQueryToTermNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [TermNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToTermNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: TermNode
}

"Connection between the RootQuery type and the Theme type"
type RootQueryToThemeConnection {
    "Edges for the RootQueryToThemeConnection connection"
    edges: [RootQueryToThemeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Theme]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToThemeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Theme
}

"Connection between the RootQuery type and the ThingILove type"
type RootQueryToThingILoveConnection {
    "Edges for the RootQueryToThingILoveConnection connection"
    edges: [RootQueryToThingILoveConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ThingILove]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToThingILoveConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ThingILove
}

"Connection between the RootQuery type and the User type"
type RootQueryToUserConnection {
    "Edges for the RootQueryToUserConnection connection"
    edges: [RootQueryToUserConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [User]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToUserConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: User
}

"Connection between the RootQuery type and the UserRole type"
type RootQueryToUserRoleConnection {
    "Edges for the RootQueryToUserRoleConnection connection"
    edges: [RootQueryToUserRoleConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [UserRole]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type RootQueryToUserRoleConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: UserRole
}

"The Yoast SEO breadcrumb config"
type SEOBreadcrumbs {
    archivePrefix: String
    boldLast: Boolean
    enabled: Boolean
    homeText: String
    notFoundText: String
    prefix: String
    searchPrefix: String
    separator: String
    showBlogPage: Boolean
}

"The Yoast SEO site level configuration data"
type SEOConfig {
    breadcrumbs: SEOBreadcrumbs
    contentTypes: SEOContentTypes
    openGraph: SEOOpenGraph
    redirects: [SEORedirect]
    schema: SEOSchema
    social: SEOSocial
    webmaster: SEOWebmaster
}

"The Yoast SEO search appearance content types fields"
type SEOContentType {
    archive: SEOContentTypeArchive
    metaDesc: String
    metaRobotsNoindex: Boolean
    schema: SEOPageInfoSchema
    schemaType: String
    title: String
}

"he Yoast SEO search appearance content types fields"
type SEOContentTypeArchive {
    archiveLink: String
    breadcrumbTitle: String
    fullHead: String
    hasArchive: Boolean
    metaDesc: String
    metaRobotsNoindex: Boolean
    title: String
}

"The Yoast SEO search appearance content types"
type SEOContentTypes {
    course: SEOContentType
    downloadFreebie: SEOContentType
    downloadGrid: SEOContentType
    mediaItem: SEOContentType
    page: SEOContentType
    post: SEOContentType
    product: SEOContentType
    resourceLibrary: SEOContentType
    thingILove: SEOContentType
}

"The Open Graph data"
type SEOOpenGraph {
    defaultImage: MediaItem
    frontPage: SEOOpenGraphFrontPage
}

"The Open Graph Front page data"
type SEOOpenGraphFrontPage {
    description: String
    image: MediaItem
    title: String
}

"The Schema for post type"
type SEOPageInfoSchema {
    raw: String
}

type SEOPostTypeBreadcrumbs {
    text: String
    url: String
}

"The page info SEO details"
type SEOPostTypePageInfo {
    schema: SEOPageInfoSchema
}

"The Schema types"
type SEOPostTypeSchema {
    articleType: [String]
    pageType: [String]
    raw: String
}

"The Yoast redirect data  (Yoast Premium only)"
type SEORedirect {
    format: String
    origin: String
    target: String
    type: Int
}

"The Yoast SEO schema data"
type SEOSchema {
    companyLogo: MediaItem
    companyName: String
    companyOrPerson: String
    homeUrl: String
    inLanguage: String
    logo: MediaItem
    personLogo: MediaItem
    personName: String
    siteName: String
    siteUrl: String
    wordpressSiteName: String
}

"The Yoast SEO Social media links"
type SEOSocial {
    facebook: SEOSocialFacebook
    instagram: SEOSocialInstagram
    linkedIn: SEOSocialLinkedIn
    mySpace: SEOSocialMySpace
    pinterest: SEOSocialPinterest
    twitter: SEOSocialTwitter
    wikipedia: SEOSocialWikipedia
    youTube: SEOSocialYoutube
}

type SEOSocialFacebook {
    defaultImage: MediaItem
    url: String
}

type SEOSocialInstagram {
    url: String
}

type SEOSocialLinkedIn {
    url: String
}

type SEOSocialMySpace {
    url: String
}

type SEOSocialPinterest {
    metaTag: String
    url: String
}

type SEOSocialTwitter {
    cardType: SEOCardType
    username: String
}

type SEOSocialWikipedia {
    url: String
}

type SEOSocialYoutube {
    url: String
}

"The Schema types for Taxonomy"
type SEOTaxonomySchema {
    raw: String
}

type SEOUser {
    breadcrumbTitle: String
    canonical: String
    fullHead: String
    language: String
    metaDesc: String
    metaRobotsNofollow: String
    metaRobotsNoindex: String
    opengraphDescription: String
    opengraphImage: MediaItem
    opengraphTitle: String
    region: String
    schema: SEOUserSchema
    social: SEOUserSocial
    title: String
    twitterDescription: String
    twitterImage: MediaItem
    twitterTitle: String
}

"The Schema types for User"
type SEOUserSchema {
    articleType: [String]
    pageType: [String]
    raw: String
}

type SEOUserSocial {
    facebook: String
    instagram: String
    linkedIn: String
    mySpace: String
    pinterest: String
    soundCloud: String
    twitter: String
    wikipedia: String
    youTube: String
}

"The Yoast SEO  webmaster fields"
type SEOWebmaster {
    baiduVerify: String
    googleVerify: String
    msVerify: String
    yandexVerify: String
}

"The payload for the sendEmail mutation"
type SendEmailPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Message"
    message: String
    "Origin that sent the request"
    origin: String
    "reply To address used"
    replyTo: String
    "Was the email sent"
    sent: Boolean
    "Was the email sent"
    test: String
    "Who the email got sent to"
    to: String
}

"The payload for the sendPasswordResetEmail mutation"
type SendPasswordResetEmailPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The user that the password reset email was sent to"
    user: User
}

"All of the registered settings"
type Settings {
    "Settings of the the string Settings Group"
    discussionSettingsDefaultCommentStatus: String
    "Settings of the the string Settings Group"
    discussionSettingsDefaultPingStatus: String
    "Settings of the the string Settings Group"
    generalSettingsDateFormat: String
    "Settings of the the string Settings Group"
    generalSettingsDescription: String
    "Settings of the the string Settings Group"
    generalSettingsEmail: String
    "Settings of the the string Settings Group"
    generalSettingsLanguage: String
    "Settings of the the integer Settings Group"
    generalSettingsStartOfWeek: Int
    "Settings of the the string Settings Group"
    generalSettingsTimeFormat: String
    "Settings of the the string Settings Group"
    generalSettingsTimezone: String
    "Settings of the the string Settings Group"
    generalSettingsTitle: String
    "Settings of the the string Settings Group"
    generalSettingsUrl: String
    "Settings of the the integer Settings Group"
    readingSettingsPostsPerPage: Int
    "Settings of the the integer Settings Group"
    writingSettingsDefaultCategory: Int
    "Settings of the the string Settings Group"
    writingSettingsDefaultPostFormat: String
    "Settings of the the boolean Settings Group"
    writingSettingsUseSmilies: Boolean
}

"Shipping Zones Type"
type ShippingInfo {
    shippingZones: String
    storePostCode: Int
}

"The subCategory type"
type SubCategory implements DatabaseIdentifier & MenuItemLinkable & Node & TermNode & UniformResourceIdentifiable {
    "Connection between the subCategory type and the ContentNode type"
    contentNodes(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: SubCategoryToContentNodeConnectionWhereArgs
    ): SubCategoryToContentNodeConnection
    "The number of objects connected to the object"
    count: Int
    "The unique resource identifier path"
    databaseId: Int!
    "The description of the object"
    description: String
    "Connection between the TermNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedScriptConnection
    "Connection between the TermNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedStylesheetConnection
    "The unique resource identifier path"
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The link to the term"
    link: String
    "The human friendly name of the object."
    name: String
    "Connection between the subCategory type and the ResourceLibrary type"
    resourceLibraries(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: SubCategoryToResourceLibraryConnectionWhereArgs
    ): SubCategoryToResourceLibraryConnection
    "The Yoast SEO data of the Sub-Categories taxonomy."
    seo: TaxonomySEO
    "An alphanumeric identifier for the object unique to its type."
    slug: String
    "The id field matches the WP_Post->ID field."
    subCategoryId: Int @deprecated(reason: "Deprecated in favor of databaseId")
    "Connection between the subCategory type and the Taxonomy type"
    taxonomy: SubCategoryToTaxonomyConnectionEdge
    "The name of the taxonomy that the object is associated with"
    taxonomyName: String
    "The ID of the term group that this term object belongs to"
    termGroupId: Int
    "The taxonomy ID that the object is associated with"
    termTaxonomyId: Int
    "The unique resource identifier path"
    uri: String
}

"Connection between the subCategory type and the ContentNode type"
type SubCategoryToContentNodeConnection {
    "Edges for the SubCategoryToContentNodeConnection connection"
    edges: [SubCategoryToContentNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type SubCategoryToContentNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentNode
}

"Connection between the subCategory type and the ResourceLibrary type"
type SubCategoryToResourceLibraryConnection {
    "Edges for the SubCategoryToResourceLibraryConnection connection"
    edges: [SubCategoryToResourceLibraryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ResourceLibrary]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type SubCategoryToResourceLibraryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ResourceLibrary
}

"Connection between the subCategory type and the Taxonomy type"
type SubCategoryToTaxonomyConnectionEdge {
    "The node of the connection, without the edges"
    node: Taxonomy
}

"The tag type"
type Tag implements DatabaseIdentifier & MenuItemLinkable & Node & TermNode & UniformResourceIdentifiable {
    "Connection between the tag type and the ContentNode type"
    contentNodes(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: TagToContentNodeConnectionWhereArgs
    ): TagToContentNodeConnection
    "The number of objects connected to the object"
    count: Int
    "Connection between the tag type and the Course type"
    courses(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: TagToCourseConnectionWhereArgs
    ): TagToCourseConnection
    "The unique resource identifier path"
    databaseId: Int!
    "The description of the object"
    description: String
    "Connection between the tag type and the DownloadGrid type"
    downloadGrids(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: TagToDownloadGridConnectionWhereArgs
    ): TagToDownloadGridConnection
    "Connection between the TermNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedScriptConnection
    "Connection between the TermNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TermNodeToEnqueuedStylesheetConnection
    "The unique resource identifier path"
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The link to the term"
    link: String
    "The human friendly name of the object."
    name: String
    "Connection between the tag type and the post type"
    posts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: TagToPostConnectionWhereArgs
    ): TagToPostConnection
    "Connection between the tag type and the ResourceLibrary type"
    resourceLibraries(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: TagToResourceLibraryConnectionWhereArgs
    ): TagToResourceLibraryConnection
    "The Yoast SEO data of the Tags taxonomy."
    seo: TaxonomySEO
    "An alphanumeric identifier for the object unique to its type."
    slug: String
    "The id field matches the WP_Post->ID field."
    tagId: Int @deprecated(reason: "Deprecated in favor of databaseId")
    "Connection between the tag type and the Taxonomy type"
    taxonomy: TagToTaxonomyConnectionEdge
    "The name of the taxonomy that the object is associated with"
    taxonomyName: String
    "The ID of the term group that this term object belongs to"
    termGroupId: Int
    "The taxonomy ID that the object is associated with"
    termTaxonomyId: Int
    "The unique resource identifier path"
    uri: String
}

"Connection between the tag type and the ContentNode type"
type TagToContentNodeConnection {
    "Edges for the TagToContentNodeConnection connection"
    edges: [TagToContentNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type TagToContentNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentNode
}

"Connection between the tag type and the Course type"
type TagToCourseConnection {
    "Edges for the TagToCourseConnection connection"
    edges: [TagToCourseConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Course]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type TagToCourseConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Course
}

"Connection between the tag type and the DownloadGrid type"
type TagToDownloadGridConnection {
    "Edges for the TagToDownloadGridConnection connection"
    edges: [TagToDownloadGridConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [DownloadGrid]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type TagToDownloadGridConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: DownloadGrid
}

"Connection between the tag type and the post type"
type TagToPostConnection {
    "Edges for the TagToPostConnection connection"
    edges: [TagToPostConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Post]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type TagToPostConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Post
}

"Connection between the tag type and the ResourceLibrary type"
type TagToResourceLibraryConnection {
    "Edges for the TagToResourceLibraryConnection connection"
    edges: [TagToResourceLibraryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ResourceLibrary]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type TagToResourceLibraryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ResourceLibrary
}

"Connection between the tag type and the Taxonomy type"
type TagToTaxonomyConnectionEdge {
    "The node of the connection, without the edges"
    node: Taxonomy
}

"A taxonomy object"
type Taxonomy implements Node {
    "List of Content Types associated with the Taxonomy"
    connectedContentTypes(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): TaxonomyToContentTypeConnection
    "Description of the taxonomy. This field is equivalent to WP_Taxonomy->description"
    description: String
    "The plural name of the post type within the GraphQL Schema."
    graphqlPluralName: String
    "The singular name of the post type within the GraphQL Schema."
    graphqlSingleName: String
    "Whether the taxonomy is hierarchical"
    hierarchical: Boolean
    "The globally unique identifier of the taxonomy object."
    id: ID!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Name of the taxonomy shown in the menu. Usually plural."
    label: String
    "The display name of the taxonomy. This field is equivalent to WP_Taxonomy->label"
    name: String
    "Whether the taxonomy is publicly queryable"
    public: Boolean
    "Name of content type to diplay in REST API "wp/v2" namespace."
    restBase: String
    "The REST Controller class assigned to handling this content type."
    restControllerClass: String
    "Whether to show the taxonomy as part of a tag cloud widget. This field is equivalent to WP_Taxonomy->show_tagcloud"
    showCloud: Boolean
    "Whether to display a column for the taxonomy on its post type listing screens."
    showInAdminColumn: Boolean
    "Whether to add the post type to the GraphQL Schema."
    showInGraphql: Boolean
    "Whether to show the taxonomy in the admin menu"
    showInMenu: Boolean
    "Whether the taxonomy is available for selection in navigation menus."
    showInNavMenus: Boolean
    "Whether to show the taxonomy in the quick/bulk edit panel."
    showInQuickEdit: Boolean
    "Whether to add the post type route in the REST API "wp/v2" namespace."
    showInRest: Boolean
    "Whether to generate and allow a UI for managing terms in this taxonomy in the admin"
    showUi: Boolean
}

type TaxonomySEO {
    breadcrumbs: [SEOPostTypeBreadcrumbs]
    canonical: String
    cornerstone: Boolean
    focuskw: String
    fullHead: String
    metaDesc: String
    metaKeywords: String
    metaRobotsNofollow: String
    metaRobotsNoindex: String
    opengraphAuthor: String
    opengraphDescription: String
    opengraphImage: MediaItem
    opengraphModifiedTime: String
    opengraphPublishedTime: String
    opengraphPublisher: String
    opengraphSiteName: String
    opengraphTitle: String
    opengraphType: String
    opengraphUrl: String
    schema: SEOTaxonomySchema
    title: String
    twitterDescription: String
    twitterImage: MediaItem
    twitterTitle: String
}

"Connection between the Taxonomy type and the ContentType type"
type TaxonomyToContentTypeConnection {
    "Edges for the TaxonomyToContentTypeConnection connection"
    edges: [TaxonomyToContentTypeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentType]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type TaxonomyToContentTypeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentType
}

"Connection between the TermNode type and the EnqueuedScript type"
type TermNodeToEnqueuedScriptConnection {
    "Edges for the TermNodeToEnqueuedScriptConnection connection"
    edges: [TermNodeToEnqueuedScriptConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [EnqueuedScript]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type TermNodeToEnqueuedScriptConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: EnqueuedScript
}

"Connection between the TermNode type and the EnqueuedStylesheet type"
type TermNodeToEnqueuedStylesheetConnection {
    "Edges for the TermNodeToEnqueuedStylesheetConnection connection"
    edges: [TermNodeToEnqueuedStylesheetConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [EnqueuedStylesheet]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type TermNodeToEnqueuedStylesheetConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: EnqueuedStylesheet
}

"A theme object"
type Theme implements Node {
    "Name of the theme author(s), could also be a company name. This field is equivalent to WP_Theme->get( "Author" )."
    author: String
    "URI for the author/company website. This field is equivalent to WP_Theme->get( "AuthorURI" )."
    authorUri: String
    "The description of the theme. This field is equivalent to WP_Theme->get( "Description" )."
    description: String
    "The globally unique identifier of the theme object."
    id: ID!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Display name of the theme. This field is equivalent to WP_Theme->get( "Name" )."
    name: String
    "The URL of the screenshot for the theme. The screenshot is intended to give an overview of what the theme looks like. This field is equivalent to WP_Theme->get_screenshot()."
    screenshot: String
    "The theme slug is used to internally match themes. Theme slugs can have subdirectories like: my-theme/sub-theme. This field is equivalent to WP_Theme->get_stylesheet()."
    slug: String
    "URI for the author/company website. This field is equivalent to WP_Theme->get( "Tags" )."
    tags: [String]
    "A URI if the theme has a website associated with it. The Theme URI is handy for directing users to a theme site for support etc. This field is equivalent to WP_Theme->get( "ThemeURI" )."
    themeUri: String
    "The current version of the theme. This field is equivalent to WP_Theme->get( "Version" )."
    version: String
}

"Dashboard options."
type ThemeOptions {
    "Added to the GraphQL Schema because the ACF Field Group "Course Launch Banners" was set to Show in GraphQL."
    courseLaunchBanners: ThemeOptions_Courselaunchbanners
    pageSlug: String
    pageTitle: String
    "Added to the GraphQL Schema because the ACF Field Group "Environment Setup" was set to Show in GraphQL."
    serverSettings: ThemeOptions_Serversettings
}

"Field Group"
type ThemeOptions_Courselaunchbanners implements AcfFieldGroup {
    basicBanner: ThemeOptions_Courselaunchbanners_BasicBanner
    "The name of the ACF Field Group"
    fieldGroupName: String
    lfmBanner: ThemeOptions_Courselaunchbanners_LfmBanner
}

"Field Group"
type ThemeOptions_Courselaunchbanners_BasicBanner implements AcfFieldGroup {
    color: String
    "Choose the launch end date and time"
    endDate: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Display Banner?"
    showBanner: String
    title: String
    url: String
}

"Field Group"
type ThemeOptions_Courselaunchbanners_LfmBanner implements AcfFieldGroup {
    "Choose the launch end date and time"
    endDate: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    "Disable the Mini Course Signup when getting close to an LFM launch"
    minicourseSignup: Boolean
    "Select the next launch date & time. (Time should normally be 10 am)"
    nextLaunchDate: String
    "Display Banner?"
    showBanner: String
}

"Field Group"
type ThemeOptions_Serversettings implements AcfFieldGroup {
    "Select the server the theme is currently using"
    etwpHeadlessServer: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    githubToken: String
    "Select the e-commerce platform for product delivery"
    productPlatform: String
}

"The ThingILove type"
type ThingILove implements ContentNode & DatabaseIdentifier & MenuItemLinkable & Node & NodeWithFeaturedImage & NodeWithTemplate & NodeWithTitle & UniformResourceIdentifiable {
    "Added to the GraphQL Schema because the ACF Field Group "Things I love" was set to Show in GraphQL."
    TIL_acfData: ThingILove_TilAcfdata
    "Connection between the ThingILove type and the category type"
    categories(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ThingILoveToCategoryConnectionWhereArgs
    ): ThingILoveToCategoryConnection
    "Connection between the ContentNode type and the ContentType type"
    contentType: ContentNodeToContentTypeConnectionEdge
    "The name of the Content Type the node belongs to"
    contentTypeName: String!
    "The unique resource identifier path"
    databaseId: Int!
    "Post publishing date."
    date: String
    "The publishing date set in GMT."
    dateGmt: String
    "The desired slug of the post"
    desiredSlug: String
    "If a user has edited the node within the past 15 seconds, this will return the user that last edited. Null if the edit lock doesn't exist or is greater than 15 seconds"
    editingLockedBy: ContentNodeToEditLockConnectionEdge
    "The RSS enclosure for the object"
    enclosure: String
    "Connection between the ContentNode type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedScriptConnection
    "Connection between the ContentNode type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): ContentNodeToEnqueuedStylesheetConnection
    "Connection between the NodeWithFeaturedImage type and the MediaItem type"
    featuredImage: NodeWithFeaturedImageToMediaItemConnectionEdge
    "The database identifier for the featured image node assigned to the content node"
    featuredImageDatabaseId: Int
    "Globally unique ID of the featured image assigned to the node"
    featuredImageId: ID
    "The global unique identifier for this post. This currently matches the value stored in WP_Post->guid and the guid column in the "post_objects" database table."
    guid: String
    "The globally unique identifier of the things-i-love object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the object is a node in the preview state"
    isPreview: Boolean
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The user that most recently edited the node"
    lastEditedBy: ContentNodeToEditLastConnectionEdge
    "The permalink of the post"
    link: String
    "The local modified time for a post. If a post was recently updated the modified field will change to match the corresponding time."
    modified: String
    "The GMT modified time for a post. If a post was recently updated the modified field will change to match the corresponding time in GMT."
    modifiedGmt: String
    "Connection between the ThingILove type and the ThingILove type"
    preview: ThingILoveToPreviewConnectionEdge
    "The database id of the preview node"
    previewRevisionDatabaseId: Int
    "Whether the object is a node in the preview state"
    previewRevisionId: ID
    "The Yoast SEO data of the ContentNode"
    seo: PostTypeSEO
    "The uri slug for the post. This is equivalent to the WP_Post->post_name field and the post_name column in the database for the "post_objects" table."
    slug: String
    "The current status of the object"
    status: String
    "The template assigned to a node of content"
    template: ContentTemplate
    "Connection between the ThingILove type and the TermNode type"
    terms(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: ThingILoveToTermNodeConnectionWhereArgs
    ): ThingILoveToTermNodeConnection
    "The id field matches the WP_Post->ID field."
    thingILoveId: Int! @deprecated(reason: "Deprecated in favor of the databaseId field")
    "The title of the post. This is currently just the raw title. An amendment to support rendered title needs to be made."
    title(
        "Format of the field output"
        format: PostObjectFieldFormatEnum
    ): String
    "The unique resource identifier path"
    uri: String
}

"Connection between the ThingILove type and the category type"
type ThingILoveToCategoryConnection {
    "Edges for the ThingILoveToCategoryConnection connection"
    edges: [ThingILoveToCategoryConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Category]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ThingILoveToCategoryConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The Yoast SEO Primary category"
    isPrimary: Boolean
    "The item at the end of the edge"
    node: Category
}

"Connection between the ThingILove type and the ThingILove type"
type ThingILoveToPreviewConnectionEdge {
    "The node of the connection, without the edges"
    node: ThingILove
}

"Connection between the ThingILove type and the TermNode type"
type ThingILoveToTermNodeConnection {
    "Edges for the ThingILoveToTermNodeConnection connection"
    edges: [ThingILoveToTermNodeConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [TermNode]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type ThingILoveToTermNodeConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: TermNode
}

"Field Group"
type ThingILove_TilAcfdata implements AcfFieldGroup {
    "The name of the ACF Field Group"
    fieldGroupName: String
    "List of the items in this category"
    items: [ThingILove_TilAcfdata_items]
}

"Field Group"
type ThingILove_TilAcfdata_items implements AcfFieldGroup {
    description: String
    "The name of the ACF Field Group"
    fieldGroupName: String
    image: MediaItem
    link: String
    name: String
}

"The payload for the UpdateCategory mutation"
type UpdateCategoryPayload {
    "The created category"
    category: Category
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
}

"The payload for the updateComment mutation"
type UpdateCommentPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The comment that was created"
    comment: Comment
    "Whether the mutation succeeded. If the comment is not approved, the server will not return the comment to a non authenticated user, but a success message can be returned if the create succeeded, and the client can optimistically add the comment to the client cache"
    success: Boolean
}

"The payload for the updateCourse mutation"
type UpdateCoursePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    course: Course
}

"The payload for the updateDownloadFreebie mutation"
type UpdateDownloadFreebiePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    downloadFreebie: DownloadFreebie
}

"The payload for the updateDownloadGrid mutation"
type UpdateDownloadGridPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    downloadGrid: DownloadGrid
}

"The payload for the updateMediaItem mutation"
type UpdateMediaItemPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The MediaItem object mutation type."
    mediaItem: MediaItem
}

"The payload for the updatePage mutation"
type UpdatePagePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    page: Page
}

"The payload for the UpdatePostFormat mutation"
type UpdatePostFormatPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The created post_format"
    postFormat: PostFormat
}

"The payload for the updatePost mutation"
type UpdatePostPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    post: Post
}

"The payload for the updateProduct mutation"
type UpdateProductPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    product: Product
}

"The payload for the updateResourceLibrary mutation"
type UpdateResourceLibraryPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    resourceLibrary: ResourceLibrary
}

"The payload for the updateSettings mutation"
type UpdateSettingsPayload {
    "Update all settings."
    allSettings: Settings
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Update the DiscussionSettings setting."
    discussionSettings: DiscussionSettings
    "Update the GeneralSettings setting."
    generalSettings: GeneralSettings
    "Update the ReadingSettings setting."
    readingSettings: ReadingSettings
    "Update the WritingSettings setting."
    writingSettings: WritingSettings
}

"The payload for the UpdateSubCategory mutation"
type UpdateSubCategoryPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The created subcategory"
    subCategory: SubCategory
}

"The payload for the UpdateTag mutation"
type UpdateTagPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The created post_tag"
    tag: Tag
}

"The payload for the updateThingILove mutation"
type UpdateThingILovePayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The Post object mutation type."
    thingILove: ThingILove
}

"The payload for the updateUser mutation"
type UpdateUserPayload {
    "If a 'clientMutationId' input is provided to the mutation, it will be returned as output on the mutation. This ID can be used by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The User object mutation type."
    user: User
}

"A User object"
type User implements Commenter & DatabaseIdentifier & Node & UniformResourceIdentifiable {
    "Avatar object for user. The avatar object can be retrieved in different sizes by specifying the size argument."
    avatar(
        "Whether to always show the default image, never the Gravatar. Default false"
        forceDefault: Boolean,
        "The rating level of the avatar."
        rating: AvatarRatingEnum,
        "The size attribute of the avatar field can be used to fetch avatars of different sizes. The value corresponds to the dimension in pixels to fetch. The default is 96 pixels."
        size: Int = 96
    ): Avatar
    "User metadata option name. Usually it will be "wp_capabilities"."
    capKey: String
    "A list of capabilities (permissions) granted to the user"
    capabilities: [String]
    "Connection between the User type and the Comment type"
    comments(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: UserToCommentConnectionWhereArgs
    ): UserToCommentConnection
    "Identifies the primary key from the database."
    databaseId: Int!
    "Description of the user."
    description: String
    "Email address of the user. This is equivalent to the WP_User->user_email property."
    email: String
    "Connection between the User type and the EnqueuedScript type"
    enqueuedScripts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): UserToEnqueuedScriptConnection
    "Connection between the User type and the EnqueuedStylesheet type"
    enqueuedStylesheets(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): UserToEnqueuedStylesheetConnection
    "A complete list of capabilities including capabilities inherited from a role. This is equivalent to the array keys of WP_User->allcaps."
    extraCapabilities: [String]
    "First name of the user. This is equivalent to the WP_User->user_first_name property."
    firstName: String
    "The globally unique identifier for the user object."
    id: ID!
    "Whether the node is a Content Node"
    isContentNode: Boolean!
    "Whether the JWT User secret has been revoked. If the secret has been revoked, auth tokens will not be issued until an admin, or user with proper capabilities re-issues a secret for the user."
    isJwtAuthSecretRevoked: Boolean!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "Whether the node is a Term"
    isTermNode: Boolean!
    "The expiration for the JWT Token for the user. If not set custom for the user, it will use the default sitewide expiration setting"
    jwtAuthExpiration: String
    "A JWT token that can be used in future requests for authentication/authorization"
    jwtAuthToken: String
    "A JWT token that can be used in future requests to get a refreshed jwtAuthToken. If the refresh token used in a request is revoked or otherwise invalid, a valid Auth token will NOT be issued in the response headers."
    jwtRefreshToken: String
    "A unique secret tied to the users JWT token that can be revoked or refreshed. Revoking the secret prevents JWT tokens from being issued to the user. Refreshing the token invalidates previously issued tokens, but allows new tokens to be issued."
    jwtUserSecret: String
    "Last name of the user. This is equivalent to the WP_User->user_last_name property."
    lastName: String
    "The preferred language locale set for the user. Value derived from get_user_locale()."
    locale: String
    "Connection between the User type and the mediaItem type"
    mediaItems(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: UserToMediaItemConnectionWhereArgs
    ): UserToMediaItemConnection
    "Display name of the user. This is equivalent to the WP_User->dispaly_name property."
    name: String
    "The nicename for the user. This field is equivalent to WP_User->user_nicename"
    nicename: String
    "Nickname of the user."
    nickname: String
    "Connection between the User type and the page type"
    pages(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: UserToPageConnectionWhereArgs
    ): UserToPageConnection
    "Connection between the User type and the post type"
    posts(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: UserToPostConnectionWhereArgs
    ): UserToPostConnection
    "The date the user registered or was created. The field follows a full ISO8601 date string format."
    registeredDate: String
    "Connection between the User and Revisions authored by the user"
    revisions(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int,
        "Arguments for filtering the connection"
        where: UserToContentRevisionUnionConnectionWhereArgs
    ): UserToContentRevisionUnionConnection
    "Connection between the User type and the UserRole type"
    roles(
        "Cursor used along with the \"first\" argument to reference where in the dataset to get data"
        after: String,
        "Cursor used along with the \"last\" argument to reference where in the dataset to get data"
        before: String,
        "The number of items to return after the referenced \"after\" cursor"
        first: Int,
        "The number of items to return before the referenced \"before\" cursor"
        last: Int
    ): UserToUserRoleConnection
    "The Yoast SEO data of a user"
    seo: SEOUser
    "The slug for the user. This field is equivalent to WP_User->user_nicename"
    slug: String
    "The unique resource identifier path"
    uri: String
    "A website url that is associated with the user."
    url: String
    "The Id of the user. Equivalent to WP_User->ID"
    userId: Int @deprecated(reason: "Deprecated in favor of the databaseId field")
    "Username for the user. This field is equivalent to WP_User->user_login."
    username: String
}

"A user role object"
type UserRole implements Node {
    "The capabilities that belong to this role"
    capabilities: [String]
    "The display name of the role"
    displayName: String
    "The globally unique identifier for the user role object."
    id: ID!
    "Whether the object is restricted from the current viewer"
    isRestricted: Boolean
    "The registered name of the role"
    name: String
}

"Connection between the User type and the Comment type"
type UserToCommentConnection {
    "Edges for the UserToCommentConnection connection"
    edges: [UserToCommentConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Comment]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type UserToCommentConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Comment
}

"Connection between the User type and the ContentRevisionUnion type"
type UserToContentRevisionUnionConnection {
    "Edges for the UserToContentRevisionUnionConnection connection"
    edges: [UserToContentRevisionUnionConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [ContentRevisionUnion]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type UserToContentRevisionUnionConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: ContentRevisionUnion
}

"Connection between the User type and the EnqueuedScript type"
type UserToEnqueuedScriptConnection {
    "Edges for the UserToEnqueuedScriptConnection connection"
    edges: [UserToEnqueuedScriptConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [EnqueuedScript]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type UserToEnqueuedScriptConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: EnqueuedScript
}

"Connection between the User type and the EnqueuedStylesheet type"
type UserToEnqueuedStylesheetConnection {
    "Edges for the UserToEnqueuedStylesheetConnection connection"
    edges: [UserToEnqueuedStylesheetConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [EnqueuedStylesheet]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type UserToEnqueuedStylesheetConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: EnqueuedStylesheet
}

"Connection between the User type and the mediaItem type"
type UserToMediaItemConnection {
    "Edges for the UserToMediaItemConnection connection"
    edges: [UserToMediaItemConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [MediaItem]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type UserToMediaItemConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: MediaItem
}

"Connection between the User type and the page type"
type UserToPageConnection {
    "Edges for the UserToPageConnection connection"
    edges: [UserToPageConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Page]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type UserToPageConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Page
}

"Connection between the User type and the post type"
type UserToPostConnection {
    "Edges for the UserToPostConnection connection"
    edges: [UserToPostConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [Post]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type UserToPostConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: Post
}

"Connection between the User type and the UserRole type"
type UserToUserRoleConnection {
    "Edges for the UserToUserRoleConnection connection"
    edges: [UserToUserRoleConnectionEdge]
    "The nodes of the connection, without the edges"
    nodes: [UserRole]
    "Information about pagination in a connection."
    pageInfo: WPPageInfo
}

"An edge in a connection"
type UserToUserRoleConnectionEdge {
    "A cursor for use in pagination"
    cursor: String
    "The item at the end of the edge"
    node: UserRole
}

"Information about pagination in a connection."
type WPPageInfo {
    "When paginating forwards, the cursor to continue."
    endCursor: String
    "When paginating forwards, are there more items?"
    hasNextPage: Boolean!
    "When paginating backwards, are there more items?"
    hasPreviousPage: Boolean!
    "Raw schema for page"
    seo: SEOPostTypePageInfo
    "When paginating backwards, the cursor to continue."
    startCursor: String
}

"Countries Type"
type WooCountries {
    billingCountries: [WooCountry]
    shippingCountries: [WooCountry]
}

type WooCountry {
    countryCode: String
    countryName: String
}

type WooState {
    stateCode: String
    stateName: String
}

"States Type"
type WooStates {
    states: [WooState]
}

"The writing setting type"
type WritingSettings {
    "Default post category."
    defaultCategory: Int
    "Default post format."
    defaultPostFormat: String
    "Convert emoticons like :-) and :-P to graphics on display."
    useSmilies: Boolean
}

"What rating to display avatars up to. Accepts 'G', 'PG', 'R', 'X', and are judged in that order. Default is the value of the 'avatar_rating' option"
enum AvatarRatingEnum {
    "Indicates a G level avatar rating level."
    G
    "Indicates a PG level avatar rating level."
    PG
    "Indicates an R level avatar rating level."
    R
    "Indicates an X level avatar rating level."
    X
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum CategoryIdType {
    "The Database ID for the node"
    DATABASE_ID
    "The hashed Global ID"
    ID
    "The name of the node"
    NAME
    "Url friendly name of the node"
    SLUG
    "The URI for the node"
    URI
}

"Options for ordering the connection"
enum CommentsConnectionOrderbyEnum {
    "Order by browser user agent of the commenter."
    COMMENT_AGENT
    "Order by true/false approval of the comment."
    COMMENT_APPROVED
    "Order by name of the comment author."
    COMMENT_AUTHOR
    "Order by e-mail of the comment author."
    COMMENT_AUTHOR_EMAIL
    "Order by IP address of the comment author."
    COMMENT_AUTHOR_IP
    "Order by URL address of the comment author."
    COMMENT_AUTHOR_URL
    "Order by the comment contents."
    COMMENT_CONTENT
    "Order by date/time timestamp of the comment."
    COMMENT_DATE
    "Order by GMT timezone date/time timestamp of the comment."
    COMMENT_DATE_GMT
    "Order by the globally unique identifier for the comment object"
    COMMENT_ID
    "Order by the array list of comment IDs listed in the where clause."
    COMMENT_IN
    "Order by the comment karma score."
    COMMENT_KARMA
    "Order by the comment parent ID."
    COMMENT_PARENT
    "Order by the post object ID."
    COMMENT_POST_ID
    "Order by the the type of comment, such as 'comment', 'pingback', or 'trackback'."
    COMMENT_TYPE
    "Order by the user ID."
    USER_ID
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum ContentNodeIdTypeEnum {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the URI."
    URI
}

"Allowed Content Types"
enum ContentTypeEnum {
    "The Type of Content object"
    ATTACHMENT
    "The Type of Content object"
    COURSES
    "The Type of Content object"
    DOWNLOADGRID
    "The Type of Content object"
    ETDM_DOWNLOAD
    "The Type of Content object"
    ET_FREEBIE
    "The Type of Content object"
    PAGE
    "The Type of Content object"
    POST
    "The Type of Content object"
    PRODUCT
    "The Type of Content object"
    THINGS_I_LOVE
}

"The Type of Identifier used to fetch a single Content Type node. To be used along with the \"id\" field. Default is \"ID\"."
enum ContentTypeIdTypeEnum {
    "The globally unique ID"
    ID
    "The name of the content type."
    NAME
}

"Allowed Content Types of the Category taxonomy."
enum ContentTypesOfCategoryEnum {
    "The Type of Content object"
    COURSES
    "The Type of Content object"
    ET_FREEBIE
    "The Type of Content object"
    POST
    "The Type of Content object"
    PRODUCT
    "The Type of Content object"
    THINGS_I_LOVE
}

"Allowed Content Types of the PostFormat taxonomy."
enum ContentTypesOfPostFormatEnum {
    "The Type of Content object"
    POST
    "The Type of Content object"
    PRODUCT
}

"Allowed Content Types of the SubCategory taxonomy."
enum ContentTypesOfSubCategoryEnum {
    "The Type of Content object"
    ET_FREEBIE
}

"Allowed Content Types of the Tag taxonomy."
enum ContentTypesOfTagEnum {
    "The Type of Content object"
    COURSES
    "The Type of Content object"
    DOWNLOADGRID
    "The Type of Content object"
    ET_FREEBIE
    "The Type of Content object"
    POST
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum CourseIdType {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the slug. Available to non-hierarchcial Types where the slug is a unique identifier."
    SLUG
    "Identify a resource by the URI."
    URI
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum DownloadFreebieIdType {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the slug. Available to non-hierarchcial Types where the slug is a unique identifier."
    SLUG
    "Identify a resource by the URI."
    URI
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum DownloadGridIdType {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the slug. Available to non-hierarchcial Types where the slug is a unique identifier."
    SLUG
    "Identify a resource by the URI."
    URI
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum MediaItemIdType {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the slug. Available to non-hierarchcial Types where the slug is a unique identifier."
    SLUG
    "Identify a media item by its source url"
    SOURCE_URL
    "Identify a resource by the URI."
    URI
}

"The size of the media item object."
enum MediaItemSizeEnum {
    "MediaItem with the headless_block_medium size"
    HEADLESS_BLOCK_MEDIUM
    "MediaItem with the headless_post_feature_image size"
    HEADLESS_POST_FEATURE_IMAGE
    "MediaItem with the headless_post_thumbnail size"
    HEADLESS_POST_THUMBNAIL
    "MediaItem with the headless_resource_image size"
    HEADLESS_RESOURCE_IMAGE
    "MediaItem with the large size"
    LARGE
    "MediaItem with the medium size"
    MEDIUM
    "MediaItem with the medium_large size"
    MEDIUM_LARGE
    "MediaItem with the placeholder size"
    PLACEHOLDER
    "MediaItem with the post-thumbnail size"
    POST_THUMBNAIL
    "MediaItem with the readanddigest_post_feature_image size"
    READANDDIGEST_POST_FEATURE_IMAGE
    "MediaItem with the thumbnail size"
    THUMBNAIL
    "MediaItem with the 1536x1536 size"
    _1536X1536
    "MediaItem with the 2048x2048 size"
    _2048X2048
}

"The status of the media item object."
enum MediaItemStatusEnum {
    "Objects with the auto-draft status"
    AUTO_DRAFT
    "Objects with the inherit status"
    INHERIT
    "Objects with the private status"
    PRIVATE
    "Objects with the trash status"
    TRASH
}

"The Type of Identifier used to fetch a single node. Default is \"ID\". To be used along with the \"id\" field."
enum MenuItemNodeIdTypeEnum {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
}

"Registered menu locations"
enum MenuLocationEnum {
    "Put the menu in the footer-menu location"
    FOOTER_MENU
    "Put the menu in the hcms-menu-footer location"
    HCMS_MENU_FOOTER
    "Put the menu in the hcms-menu-header location"
    HCMS_MENU_HEADER
    "Put the menu in the mobile-menu location"
    MOBILE_MENU
    "Put the menu in the primary-menu location"
    PRIMARY_MENU
}

"The Type of Identifier used to fetch a single node. Default is \"ID\". To be used along with the \"id\" field."
enum MenuNodeIdTypeEnum {
    "Identify a menu node by the Database ID."
    DATABASE_ID
    "Identify a menu node by the (hashed) Global ID."
    ID
    "Identify a menu node by the slug of menu location to which it is assigned"
    LOCATION
    "Identify a menu node by its name"
    NAME
    "Identify a menu node by its slug"
    SLUG
}

"The MimeType of the object"
enum MimeTypeEnum {
    "MimeType application/java"
    APPLICATION_JAVA
    "MimeType application/msword"
    APPLICATION_MSWORD
    "MimeType application/octet-stream"
    APPLICATION_OCTET_STREAM
    "MimeType application/onenote"
    APPLICATION_ONENOTE
    "MimeType application/oxps"
    APPLICATION_OXPS
    "MimeType application/pdf"
    APPLICATION_PDF
    "MimeType application/rar"
    APPLICATION_RAR
    "MimeType application/rtf"
    APPLICATION_RTF
    "MimeType application/ttaf+xml"
    APPLICATION_TTAF_XML
    "MimeType application/vnd.apple.keynote"
    APPLICATION_VND_APPLE_KEYNOTE
    "MimeType application/vnd.apple.numbers"
    APPLICATION_VND_APPLE_NUMBERS
    "MimeType application/vnd.apple.pages"
    APPLICATION_VND_APPLE_PAGES
    "MimeType application/vnd.ms-access"
    APPLICATION_VND_MS_ACCESS
    "MimeType application/vnd.ms-excel"
    APPLICATION_VND_MS_EXCEL
    "MimeType application/vnd.ms-excel.addin.macroEnabled.12"
    APPLICATION_VND_MS_EXCEL_ADDIN_MACROENABLED_12
    "MimeType application/vnd.ms-excel.sheet.binary.macroEnabled.12"
    APPLICATION_VND_MS_EXCEL_SHEET_BINARY_MACROENABLED_12
    "MimeType application/vnd.ms-excel.sheet.macroEnabled.12"
    APPLICATION_VND_MS_EXCEL_SHEET_MACROENABLED_12
    "MimeType application/vnd.ms-excel.template.macroEnabled.12"
    APPLICATION_VND_MS_EXCEL_TEMPLATE_MACROENABLED_12
    "MimeType application/vnd.ms-powerpoint"
    APPLICATION_VND_MS_POWERPOINT
    "MimeType application/vnd.ms-powerpoint.addin.macroEnabled.12"
    APPLICATION_VND_MS_POWERPOINT_ADDIN_MACROENABLED_12
    "MimeType application/vnd.ms-powerpoint.presentation.macroEnabled.12"
    APPLICATION_VND_MS_POWERPOINT_PRESENTATION_MACROENABLED_12
    "MimeType application/vnd.ms-powerpoint.slideshow.macroEnabled.12"
    APPLICATION_VND_MS_POWERPOINT_SLIDESHOW_MACROENABLED_12
    "MimeType application/vnd.ms-powerpoint.slide.macroEnabled.12"
    APPLICATION_VND_MS_POWERPOINT_SLIDE_MACROENABLED_12
    "MimeType application/vnd.ms-powerpoint.template.macroEnabled.12"
    APPLICATION_VND_MS_POWERPOINT_TEMPLATE_MACROENABLED_12
    "MimeType application/vnd.ms-project"
    APPLICATION_VND_MS_PROJECT
    "MimeType application/vnd.ms-word.document.macroEnabled.12"
    APPLICATION_VND_MS_WORD_DOCUMENT_MACROENABLED_12
    "MimeType application/vnd.ms-word.template.macroEnabled.12"
    APPLICATION_VND_MS_WORD_TEMPLATE_MACROENABLED_12
    "MimeType application/vnd.ms-write"
    APPLICATION_VND_MS_WRITE
    "MimeType application/vnd.ms-xpsdocument"
    APPLICATION_VND_MS_XPSDOCUMENT
    "MimeType application/vnd.oasis.opendocument.chart"
    APPLICATION_VND_OASIS_OPENDOCUMENT_CHART
    "MimeType application/vnd.oasis.opendocument.database"
    APPLICATION_VND_OASIS_OPENDOCUMENT_DATABASE
    "MimeType application/vnd.oasis.opendocument.formula"
    APPLICATION_VND_OASIS_OPENDOCUMENT_FORMULA
    "MimeType application/vnd.oasis.opendocument.graphics"
    APPLICATION_VND_OASIS_OPENDOCUMENT_GRAPHICS
    "MimeType application/vnd.oasis.opendocument.presentation"
    APPLICATION_VND_OASIS_OPENDOCUMENT_PRESENTATION
    "MimeType application/vnd.oasis.opendocument.spreadsheet"
    APPLICATION_VND_OASIS_OPENDOCUMENT_SPREADSHEET
    "MimeType application/vnd.oasis.opendocument.text"
    APPLICATION_VND_OASIS_OPENDOCUMENT_TEXT
    "MimeType application/vnd.openxmlformats-officedocument.presentationml.presentation"
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_PRESENTATIONML_PRESENTATION
    "MimeType application/vnd.openxmlformats-officedocument.presentationml.slide"
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_PRESENTATIONML_SLIDE
    "MimeType application/vnd.openxmlformats-officedocument.presentationml.slideshow"
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_PRESENTATIONML_SLIDESHOW
    "MimeType application/vnd.openxmlformats-officedocument.presentationml.template"
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_PRESENTATIONML_TEMPLATE
    "MimeType application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_SPREADSHEETML_SHEET
    "MimeType application/vnd.openxmlformats-officedocument.spreadsheetml.template"
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_SPREADSHEETML_TEMPLATE
    "MimeType application/vnd.openxmlformats-officedocument.wordprocessingml.document"
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_WORDPROCESSINGML_DOCUMENT
    "MimeType application/vnd.openxmlformats-officedocument.wordprocessingml.template"
    APPLICATION_VND_OPENXMLFORMATS_OFFICEDOCUMENT_WORDPROCESSINGML_TEMPLATE
    "MimeType application/wordperfect"
    APPLICATION_WORDPERFECT
    "MimeType application/x-7z-compressed"
    APPLICATION_X_7Z_COMPRESSED
    "MimeType application/x-gzip"
    APPLICATION_X_GZIP
    "MimeType application/x-tar"
    APPLICATION_X_TAR
    "MimeType application/zip"
    APPLICATION_ZIP
    "MimeType audio/aac"
    AUDIO_AAC
    "MimeType audio/flac"
    AUDIO_FLAC
    "MimeType audio/midi"
    AUDIO_MIDI
    "MimeType audio/mpeg"
    AUDIO_MPEG
    "MimeType audio/ogg"
    AUDIO_OGG
    "MimeType audio/wav"
    AUDIO_WAV
    "MimeType audio/x-matroska"
    AUDIO_X_MATROSKA
    "MimeType audio/x-ms-wax"
    AUDIO_X_MS_WAX
    "MimeType audio/x-ms-wma"
    AUDIO_X_MS_WMA
    "MimeType audio/x-realaudio"
    AUDIO_X_REALAUDIO
    "MimeType image/bmp"
    IMAGE_BMP
    "MimeType image/gif"
    IMAGE_GIF
    "MimeType image/heic"
    IMAGE_HEIC
    "MimeType image/jpeg"
    IMAGE_JPEG
    "MimeType image/png"
    IMAGE_PNG
    "MimeType image/tiff"
    IMAGE_TIFF
    "MimeType image/webp"
    IMAGE_WEBP
    "MimeType image/x-icon"
    IMAGE_X_ICON
    "MimeType text/calendar"
    TEXT_CALENDAR
    "MimeType text/css"
    TEXT_CSS
    "MimeType text/csv"
    TEXT_CSV
    "MimeType text/plain"
    TEXT_PLAIN
    "MimeType text/richtext"
    TEXT_RICHTEXT
    "MimeType text/tab-separated-values"
    TEXT_TAB_SEPARATED_VALUES
    "MimeType text/vtt"
    TEXT_VTT
    "MimeType video/3gpp"
    VIDEO_3GPP
    "MimeType video/3gpp2"
    VIDEO_3GPP2
    "MimeType video/avi"
    VIDEO_AVI
    "MimeType video/divx"
    VIDEO_DIVX
    "MimeType video/mp4"
    VIDEO_MP4
    "MimeType video/mpeg"
    VIDEO_MPEG
    "MimeType video/ogg"
    VIDEO_OGG
    "MimeType video/quicktime"
    VIDEO_QUICKTIME
    "MimeType video/webm"
    VIDEO_WEBM
    "MimeType video/x-flv"
    VIDEO_X_FLV
    "MimeType video/x-matroska"
    VIDEO_X_MATROSKA
    "MimeType video/x-ms-asf"
    VIDEO_X_MS_ASF
    "MimeType video/x-ms-wm"
    VIDEO_X_MS_WM
    "MimeType video/x-ms-wmv"
    VIDEO_X_MS_WMV
    "MimeType video/x-ms-wmx"
    VIDEO_X_MS_WMX
}

"The cardinality of the connection order"
enum OrderEnum {
    "Sort the query result set in an ascending order"
    ASC
    "Sort the query result set in a descending order"
    DESC
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum PageIdType {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the URI."
    URI
}

"The status of the WordPress plugin."
enum PluginStatusEnum {
    "The plugin is currently active."
    ACTIVE
    "The plugin is a drop-in plugin."
    DROP_IN
    "The plugin is currently inactive."
    INACTIVE
    "The plugin is a must-use plugin."
    MUST_USE
    "The plugin is technically active but was paused while loading."
    PAUSED
    "The plugin was active recently."
    RECENTLY_ACTIVE
    "The plugin has an upgrade available."
    UPGRADE
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum PostFormatIdType {
    "The Database ID for the node"
    DATABASE_ID
    "The hashed Global ID"
    ID
    "The name of the node"
    NAME
    "Url friendly name of the node"
    SLUG
    "The URI for the node"
    URI
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum PostIdType {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the slug. Available to non-hierarchcial Types where the slug is a unique identifier."
    SLUG
    "Identify a resource by the URI."
    URI
}

"The format of post field data."
enum PostObjectFieldFormatEnum {
    "Provide the field value directly from database. Null on unauthenticated requests."
    RAW
    "Provide the field value as rendered by WordPress. Default."
    RENDERED
}

"The column to use when filtering by date"
enum PostObjectsConnectionDateColumnEnum {
    "The date the comment was created in local time."
    DATE
    "The most recent modification date of the comment."
    MODIFIED
}

"Field to order the connection by"
enum PostObjectsConnectionOrderbyEnum {
    "Order by author"
    AUTHOR
    "Order by the number of comments it has acquired"
    COMMENT_COUNT
    "Order by publish date"
    DATE
    "Preserve the ID order given in the IN array"
    IN
    "Order by the menu order value"
    MENU_ORDER
    "Order by last modified date"
    MODIFIED
    "Preserve slug order given in the NAME_IN array"
    NAME_IN
    "Order by parent ID"
    PARENT
    "Order by slug"
    SLUG
    "Order by title"
    TITLE
}

"The status of the object."
enum PostStatusEnum {
    "Objects with the acf-disabled status"
    ACF_DISABLED
    "Objects with the auto-draft status"
    AUTO_DRAFT
    "Objects with the draft status"
    DRAFT
    "Objects with the future status"
    FUTURE
    "Objects with the inherit status"
    INHERIT
    "Objects with the pending status"
    PENDING
    "Objects with the private status"
    PRIVATE
    "Objects with the publish status"
    PUBLISH
    "Objects with the request-completed status"
    REQUEST_COMPLETED
    "Objects with the request-confirmed status"
    REQUEST_CONFIRMED
    "Objects with the request-failed status"
    REQUEST_FAILED
    "Objects with the request-pending status"
    REQUEST_PENDING
    "Objects with the trash status"
    TRASH
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum ProductIdType {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the slug. Available to non-hierarchcial Types where the slug is a unique identifier."
    SLUG
    "Identify a resource by the URI."
    URI
}

"The logical relation between each item in the array when there are more than one."
enum RelationEnum {
    "The logical AND condition returns true if both operands are true, otherwise, it returns false."
    AND
    "The logical OR condition returns false if both operands are false, otherwise, it returns true."
    OR
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum ResourceLibraryIdType {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the slug. Available to non-hierarchcial Types where the slug is a unique identifier."
    SLUG
    "Identify a resource by the URI."
    URI
}

"Types of cards"
enum SEOCardType {
    summary
    summary_large_image
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum SubCategoryIdType {
    "The Database ID for the node"
    DATABASE_ID
    "The hashed Global ID"
    ID
    "The name of the node"
    NAME
    "Url friendly name of the node"
    SLUG
    "The URI for the node"
    URI
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum TagIdType {
    "The Database ID for the node"
    DATABASE_ID
    "The hashed Global ID"
    ID
    "The name of the node"
    NAME
    "Url friendly name of the node"
    SLUG
    "The URI for the node"
    URI
}

"Allowed taxonomies"
enum TaxonomyEnum {
    "Taxonomy enum category"
    CATEGORY
    "Taxonomy enum post_format"
    POSTFORMAT
    "Taxonomy enum subcategory"
    SUBCATEGORY
    "Taxonomy enum post_tag"
    TAG
}

"The Type of Identifier used to fetch a single Taxonomy node. To be used along with the \"id\" field. Default is \"ID\"."
enum TaxonomyIdTypeEnum {
    "The globally unique ID"
    ID
    "The name of the taxonomy"
    NAME
}

"The Type of Identifier used to fetch a single resource. Default is \"ID\". To be used along with the \"id\" field."
enum TermNodeIdTypeEnum {
    "The Database ID for the node"
    DATABASE_ID
    "The hashed Global ID"
    ID
    "The name of the node"
    NAME
    "Url friendly name of the node"
    SLUG
    "The URI for the node"
    URI
}

"Options for ordering the connection by"
enum TermObjectsConnectionOrderbyEnum {
    "Order the connection by item count."
    COUNT
    "Order the connection by description."
    DESCRIPTION
    "Order the connection by name."
    NAME
    "Order the connection by slug."
    SLUG
    "Order the connection by term group."
    TERM_GROUP
    "Order the connection by term id."
    TERM_ID
    "Order the connection by term order."
    TERM_ORDER
}

"The Type of Identifier used to fetch a single resource. Default is ID."
enum ThingILoveIdType {
    "Identify a resource by the Database ID."
    DATABASE_ID
    "Identify a resource by the (hashed) Global ID."
    ID
    "Identify a resource by the slug. Available to non-hierarchcial Types where the slug is a unique identifier."
    SLUG
    "Identify a resource by the URI."
    URI
}

"The Type of Identifier used to fetch a single User node. To be used along with the \"id\" field. Default is \"ID\"."
enum UserNodeIdTypeEnum {
    "The Database ID for the node"
    DATABASE_ID
    "The Email of the User"
    EMAIL
    "The hashed Global ID"
    ID
    "The slug of the User"
    SLUG
    "The URI for the node"
    URI
    "The username the User uses to login with"
    USERNAME
}

"Names of available user roles"
enum UserRoleEnum {
    "User role with specific capabilities"
    ADMINISTRATOR
    "User role with specific capabilities"
    AUTHOR
    "User role with specific capabilities"
    CONTRIBUTOR
    "User role with specific capabilities"
    EDITOR
    "User role with specific capabilities"
    SEO_EDITOR
    "User role with specific capabilities"
    SEO_MANAGER
    "User role with specific capabilities"
    SUBSCRIBER
}

"Field to order the connection by"
enum UsersConnectionOrderbyEnum {
    "Order by display name"
    DISPLAY_NAME
    "Order by email address"
    EMAIL
    "Order by login"
    LOGIN
    "Preserve the login order given in the LOGIN_IN array"
    LOGIN_IN
    "Order by nice name"
    NICE_NAME
    "Preserve the nice name order given in the NICE_NAME_IN array"
    NICE_NAME_IN
    "Order by registration date"
    REGISTERED
    "Order by URL"
    URL
}

"Column used for searching for users."
enum UsersConnectionSearchColumnEnum {
    "The user's email address."
    EMAIL
    "The globally unique ID."
    ID
    "The username the User uses to login with."
    LOGIN
    "A URL-friendly name for the user. The default is the user's username."
    NICENAME
    "The URL of the user\\s website."
    URL
}

"Input for the addToWishlist mutation"
input AddToWishlistInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Product id"
    productId: Int
}

"Arguments for filtering the CategoryToCategoryConnection connection"
input CategoryToCategoryConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the CategoryToContentNodeConnection connection"
input CategoryToContentNodeConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypesOfCategoryEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the CategoryToCourseConnection connection"
input CategoryToCourseConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the CategoryToPostConnection connection"
input CategoryToPostConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the CategoryToProductConnection connection"
input CategoryToProductConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the CategoryToResourceLibraryConnection connection"
input CategoryToResourceLibraryConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the CategoryToThingILoveConnection connection"
input CategoryToThingILoveConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the CommentToCommentConnection connection"
input CommentToCommentConnectionWhereArgs {
    "Comment author email address."
    authorEmail: String
    "Array of author IDs to include comments for."
    authorIn: [ID]
    "Array of author IDs to exclude comments for."
    authorNotIn: [ID]
    "Comment author URL."
    authorUrl: String
    "Array of comment IDs to include."
    commentIn: [ID]
    "Array of IDs of users whose unapproved comments will be returned by the query regardless of status."
    commentNotIn: [ID]
    "Include comments of a given type."
    commentType: String
    "Include comments from a given array of comment types."
    commentTypeIn: [String]
    "Exclude comments from a given array of comment types."
    commentTypeNotIn: String
    "Content object author ID to limit results by."
    contentAuthor: [ID]
    "Array of author IDs to retrieve comments for."
    contentAuthorIn: [ID]
    "Array of author IDs *not* to retrieve comments for."
    contentAuthorNotIn: [ID]
    "Limit results to those affiliated with a given content object ID."
    contentId: ID
    "Array of content object IDs to include affiliated comments for."
    contentIdIn: [ID]
    "Array of content object IDs to exclude affiliated comments for."
    contentIdNotIn: [ID]
    "Content object name to retrieve affiliated comments for."
    contentName: String
    "Content Object parent ID to retrieve affiliated comments for."
    contentParent: Int
    "Array of content object statuses to retrieve affiliated comments for. Pass 'any' to match any value."
    contentStatus: [PostStatusEnum]
    "Content object type or array of types to retrieve affiliated comments for. Pass 'any' to match any value."
    contentType: [ContentTypeEnum]
    "Array of IDs or email addresses of users whose unapproved comments will be returned by the query regardless of $status. Default empty"
    includeUnapproved: [ID]
    "Karma score to retrieve matching comments for."
    karma: Int
    "The cardinality of the order of the connection"
    order: OrderEnum
    "Field to order the comments by."
    orderby: CommentsConnectionOrderbyEnum
    "Parent ID of comment to retrieve children of."
    parent: Int
    "Array of parent IDs of comments to retrieve children for."
    parentIn: [ID]
    "Array of parent IDs of comments *not* to retrieve children for."
    parentNotIn: [ID]
    "Search term(s) to retrieve matching comments for."
    search: String
    "Comment status to limit results by."
    status: String
    "Include comments for a specific user ID."
    userId: ID
}

"Arguments for filtering the CommentToParentCommentConnection connection"
input CommentToParentCommentConnectionWhereArgs {
    "Comment author email address."
    authorEmail: String
    "Array of author IDs to include comments for."
    authorIn: [ID]
    "Array of author IDs to exclude comments for."
    authorNotIn: [ID]
    "Comment author URL."
    authorUrl: String
    "Array of comment IDs to include."
    commentIn: [ID]
    "Array of IDs of users whose unapproved comments will be returned by the query regardless of status."
    commentNotIn: [ID]
    "Include comments of a given type."
    commentType: String
    "Include comments from a given array of comment types."
    commentTypeIn: [String]
    "Exclude comments from a given array of comment types."
    commentTypeNotIn: String
    "Content object author ID to limit results by."
    contentAuthor: [ID]
    "Array of author IDs to retrieve comments for."
    contentAuthorIn: [ID]
    "Array of author IDs *not* to retrieve comments for."
    contentAuthorNotIn: [ID]
    "Limit results to those affiliated with a given content object ID."
    contentId: ID
    "Array of content object IDs to include affiliated comments for."
    contentIdIn: [ID]
    "Array of content object IDs to exclude affiliated comments for."
    contentIdNotIn: [ID]
    "Content object name to retrieve affiliated comments for."
    contentName: String
    "Content Object parent ID to retrieve affiliated comments for."
    contentParent: Int
    "Array of content object statuses to retrieve affiliated comments for. Pass 'any' to match any value."
    contentStatus: [PostStatusEnum]
    "Content object type or array of types to retrieve affiliated comments for. Pass 'any' to match any value."
    contentType: [ContentTypeEnum]
    "Array of IDs or email addresses of users whose unapproved comments will be returned by the query regardless of $status. Default empty"
    includeUnapproved: [ID]
    "Karma score to retrieve matching comments for."
    karma: Int
    "The cardinality of the order of the connection"
    order: OrderEnum
    "Field to order the comments by."
    orderby: CommentsConnectionOrderbyEnum
    "Parent ID of comment to retrieve children of."
    parent: Int
    "Array of parent IDs of comments to retrieve children for."
    parentIn: [ID]
    "Array of parent IDs of comments *not* to retrieve children for."
    parentNotIn: [ID]
    "Search term(s) to retrieve matching comments for."
    search: String
    "Comment status to limit results by."
    status: String
    "Include comments for a specific user ID."
    userId: ID
}

"Arguments for filtering the ContentTypeToContentNodeConnection connection"
input ContentTypeToContentNodeConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypeEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Set relationships between the Course to categories"
input CourseCategoriesInput {
    "If true, this will append the category to existing related categories. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [CourseCategoriesNodeInput]
}

"List of categories to connect the Course to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input CourseCategoriesNodeInput {
    "The description of the category. This field is used to set a description of the category if a new one is created during the mutation."
    description: String
    "The ID of the category. If present, this will be used to connect to the Course. If no existing category exists with this ID, no connection will be made."
    id: ID
    "The name of the category. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the category. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Set relationships between the Course to tags"
input CourseTagsInput {
    "If true, this will append the tag to existing related tags. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [CourseTagsNodeInput]
}

"List of tags to connect the Course to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input CourseTagsNodeInput {
    "The description of the tag. This field is used to set a description of the tag if a new one is created during the mutation."
    description: String
    "The ID of the tag. If present, this will be used to connect to the Course. If no existing tag exists with this ID, no connection will be made."
    id: ID
    "The name of the tag. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the tag. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Arguments for filtering the CourseToCategoryConnection connection"
input CourseToCategoryConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the CourseToTagConnection connection"
input CourseToTagConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the CourseToTermNodeConnection connection"
input CourseToTermNodeConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "The Taxonomy to filter terms by"
    taxonomies: [TaxonomyEnum]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Input for the createCategory mutation"
input CreateCategoryInput {
    "The slug that the category will be an alias of"
    aliasOf: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The description of the category object"
    description: String
    "The name of the category object to mutate"
    name: String!
    "The ID of the category that should be set as the parent"
    parentId: ID
    "If this argument exists then the slug will be checked to see if it is not an existing valid term. If that check succeeds (it is not a valid term), then it is added and the term id is given. If it fails, then a check is made to whether the taxonomy is hierarchical and the parent argument is not empty. If the second check succeeds, the term will be inserted and the term id will be given. If the slug argument is empty, then it will be calculated from the term name."
    slug: String
}

"Input for the createComment mutation"
input CreateCommentInput {
    "The approval status of the comment."
    approved: String
    "The name of the comment's author."
    author: String
    "The email of the comment's author."
    authorEmail: String
    "The url of the comment's author."
    authorUrl: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The database ID of the post object the comment belongs to."
    commentOn: Int
    "Content of the comment."
    content: String
    "The date of the object. Preferable to enter as year/month/day ( e.g. 01/31/2017 ) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "Parent comment ID of current comment."
    parent: ID
    "Type of comment."
    type: String
}

"Input for the createCourse mutation"
input CreateCourseInput {
    "Set connections between the Course and categories"
    categories: CourseCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The content of the object"
    content: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "Set connections between the Course and tags"
    tags: CourseTagsInput
    "The title of the object"
    title: String
}

"Input for the createDownloadFreebie mutation"
input CreateDownloadFreebieInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "The title of the object"
    title: String
}

"Input for the createDownloadGrid mutation"
input CreateDownloadGridInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "Set connections between the DownloadGrid and tags"
    tags: DownloadGridTagsInput
    "The title of the object"
    title: String
}

"Input for the createMediaItem mutation"
input CreateMediaItemInput {
    "Alternative text to display when mediaItem is not displayed"
    altText: String
    "The userId to assign as the author of the mediaItem"
    authorId: ID
    "The caption for the mediaItem"
    caption: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The comment status for the mediaItem"
    commentStatus: String
    "The date of the mediaItem"
    date: String
    "The date (in GMT zone) of the mediaItem"
    dateGmt: String
    "Description of the mediaItem"
    description: String
    "The file name of the mediaItem"
    filePath: String
    "The file type of the mediaItem"
    fileType: MimeTypeEnum
    "The ID of the parent object"
    parentId: ID
    "The ping status for the mediaItem"
    pingStatus: String
    "The slug of the mediaItem"
    slug: String
    "The status of the mediaItem"
    status: MediaItemStatusEnum
    "The title of the mediaItem"
    title: String
}

"Input for the createPage mutation"
input CreatePageInput {
    "The userId to assign as the author of the object"
    authorId: ID
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The comment status for the object"
    commentStatus: String
    "The content of the object"
    content: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The ID of the parent object"
    parentId: ID
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "The title of the object"
    title: String
}

"Input for the createPostFormat mutation"
input CreatePostFormatInput {
    "The slug that the post_format will be an alias of"
    aliasOf: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The description of the post_format object"
    description: String
    "The name of the post_format object to mutate"
    name: String!
    "If this argument exists then the slug will be checked to see if it is not an existing valid term. If that check succeeds (it is not a valid term), then it is added and the term id is given. If it fails, then a check is made to whether the taxonomy is hierarchical and the parent argument is not empty. If the second check succeeds, the term will be inserted and the term id will be given. If the slug argument is empty, then it will be calculated from the term name."
    slug: String
}

"Input for the createPost mutation"
input CreatePostInput {
    "The userId to assign as the author of the object"
    authorId: ID
    "Set connections between the post and categories"
    categories: PostCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The comment status for the object"
    commentStatus: String
    "The content of the object"
    content: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The excerpt of the object"
    excerpt: String
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The ping status for the object"
    pingStatus: String
    "URLs that have been pinged."
    pinged: [String]
    "Set connections between the post and postFormats"
    postFormats: PostPostFormatsInput
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "Set connections between the post and tags"
    tags: PostTagsInput
    "The title of the object"
    title: String
    "URLs queued to be pinged."
    toPing: [String]
}

"Input for the createProduct mutation"
input CreateProductInput {
    "Set connections between the Product and categories"
    categories: ProductCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "Set connections between the Product and postFormats"
    postFormats: ProductPostFormatsInput
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "The title of the object"
    title: String
}

"Input for the createResourceLibrary mutation"
input CreateResourceLibraryInput {
    "Set connections between the ResourceLibrary and categories"
    categories: ResourceLibraryCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "Set connections between the ResourceLibrary and subCategories"
    subCategories: ResourceLibrarySubCategoriesInput
    "Set connections between the ResourceLibrary and tags"
    tags: ResourceLibraryTagsInput
    "The title of the object"
    title: String
}

"Input for the createSubCategory mutation"
input CreateSubCategoryInput {
    "The slug that the subcategory will be an alias of"
    aliasOf: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The description of the subcategory object"
    description: String
    "The name of the subcategory object to mutate"
    name: String!
    "If this argument exists then the slug will be checked to see if it is not an existing valid term. If that check succeeds (it is not a valid term), then it is added and the term id is given. If it fails, then a check is made to whether the taxonomy is hierarchical and the parent argument is not empty. If the second check succeeds, the term will be inserted and the term id will be given. If the slug argument is empty, then it will be calculated from the term name."
    slug: String
}

"Input for the createTag mutation"
input CreateTagInput {
    "The slug that the post_tag will be an alias of"
    aliasOf: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The description of the post_tag object"
    description: String
    "The name of the post_tag object to mutate"
    name: String!
    "If this argument exists then the slug will be checked to see if it is not an existing valid term. If that check succeeds (it is not a valid term), then it is added and the term id is given. If it fails, then a check is made to whether the taxonomy is hierarchical and the parent argument is not empty. If the second check succeeds, the term will be inserted and the term id will be given. If the slug argument is empty, then it will be calculated from the term name."
    slug: String
}

"Input for the createThingILove mutation"
input CreateThingILoveInput {
    "Set connections between the ThingILove and categories"
    categories: ThingILoveCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "The title of the object"
    title: String
}

"Input for the createUser mutation"
input CreateUserInput {
    "User's AOL IM account."
    aim: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "A string containing content about the user."
    description: String
    "A string that will be shown on the site. Defaults to user's username. It is likely that you will want to change this, for both appearance and security through obscurity (that is if you dont use and delete the default admin user)."
    displayName: String
    "A string containing the user's email address."
    email: String
    "\tThe user's first name."
    firstName: String
    "User's Jabber account."
    jabber: String
    "The user's last name."
    lastName: String
    "User's locale."
    locale: String
    "A string that contains a URL-friendly name for the user. The default is the user's username."
    nicename: String
    "The user's nickname, defaults to the user's username."
    nickname: String
    "A string that contains the plain text password for the user."
    password: String
    "If true, this will refresh the users JWT secret."
    refreshJwtUserSecret: Boolean
    "The date the user registered. Format is Y-m-d H:i:s."
    registered: String
    "If true, this will revoke the users JWT secret. If false, this will unrevoke the JWT secret AND issue a new one. To revoke, the user must have proper capabilities to edit users JWT secrets."
    revokeJwtUserSecret: Boolean
    "A string for whether to enable the rich editor or not. False if not empty."
    richEditing: String
    "An array of roles to be assigned to the user."
    roles: [String]
    "A string that contains the user's username for logging in."
    username: String!
    "A string containing the user's URL for the user's web site."
    websiteUrl: String
    "User's Yahoo IM account."
    yim: String
}

"Date values"
input DateInput {
    "Day of the month (from 1 to 31)"
    day: Int
    "Month number (from 1 to 12)"
    month: Int
    "4 digit year (e.g. 2017)"
    year: Int
}

"Filter the connection based on input"
input DateQueryInput {
    "Nodes should be returned after this date"
    after: DateInput
    "Nodes should be returned before this date"
    before: DateInput
    "Column to query against"
    column: PostObjectsConnectionDateColumnEnum
    "For after/before, whether exact value should be matched or not"
    compare: String
    "Day of the month (from 1 to 31)"
    day: Int
    "Hour (from 0 to 23)"
    hour: Int
    "For after/before, whether exact value should be matched or not"
    inclusive: Boolean
    "Minute (from 0 to 59)"
    minute: Int
    "Month number (from 1 to 12)"
    month: Int
    "OR or AND, how the sub-arrays should be compared"
    relation: RelationEnum
    "Second (0 to 59)"
    second: Int
    "Week of the year (from 0 to 53)"
    week: Int
    "4 digit year (e.g. 2017)"
    year: Int
}

"Input for the deleteCategory mutation"
input DeleteCategoryInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the category to delete"
    id: ID!
}

"Input for the deleteComment mutation"
input DeleteCommentInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the comment should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The deleted comment ID"
    id: ID!
}

"Input for the deleteCourse mutation"
input DeleteCourseInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the object should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The ID of the Course to delete"
    id: ID!
}

"Input for the deleteDownloadFreebie mutation"
input DeleteDownloadFreebieInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the object should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The ID of the downloadFreebie to delete"
    id: ID!
}

"Input for the deleteDownloadGrid mutation"
input DeleteDownloadGridInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the object should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The ID of the DownloadGrid to delete"
    id: ID!
}

"Input for the deleteMediaItem mutation"
input DeleteMediaItemInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the mediaItem should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The ID of the mediaItem to delete"
    id: ID!
}

"Input for the deletePage mutation"
input DeletePageInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the object should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The ID of the page to delete"
    id: ID!
}

"Input for the deletePostFormat mutation"
input DeletePostFormatInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the postFormat to delete"
    id: ID!
}

"Input for the deletePost mutation"
input DeletePostInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the object should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The ID of the post to delete"
    id: ID!
}

"Input for the deleteProduct mutation"
input DeleteProductInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the object should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The ID of the Product to delete"
    id: ID!
}

"Input for the deleteResourceLibrary mutation"
input DeleteResourceLibraryInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the object should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The ID of the ResourceLibrary to delete"
    id: ID!
}

"Input for the deleteSubCategory mutation"
input DeleteSubCategoryInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the subCategory to delete"
    id: ID!
}

"Input for the deleteTag mutation"
input DeleteTagInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the tag to delete"
    id: ID!
}

"Input for the deleteThingILove mutation"
input DeleteThingILoveInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Whether the object should be force deleted instead of being moved to the trash"
    forceDelete: Boolean
    "The ID of the ThingILove to delete"
    id: ID!
}

"Input for the deleteUser mutation"
input DeleteUserInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the user you want to delete"
    id: ID!
    "Reassign posts and links to new User ID."
    reassignId: ID
}

"Set relationships between the DownloadGrid to tags"
input DownloadGridTagsInput {
    "If true, this will append the tag to existing related tags. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [DownloadGridTagsNodeInput]
}

"List of tags to connect the DownloadGrid to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input DownloadGridTagsNodeInput {
    "The description of the tag. This field is used to set a description of the tag if a new one is created during the mutation."
    description: String
    "The ID of the tag. If present, this will be used to connect to the DownloadGrid. If no existing tag exists with this ID, no connection will be made."
    id: ID
    "The name of the tag. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the tag. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Arguments for filtering the DownloadGridToTagConnection connection"
input DownloadGridToTagConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the DownloadGridToTermNodeConnection connection"
input DownloadGridToTermNodeConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "The Taxonomy to filter terms by"
    taxonomies: [TaxonomyEnum]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the HierarchicalContentNodeToContentNodeAncestorsConnection connection"
input HierarchicalContentNodeToContentNodeAncestorsConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypeEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the HierarchicalContentNodeToContentNodeChildrenConnection connection"
input HierarchicalContentNodeToContentNodeChildrenConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypeEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Input for the login mutation"
input LoginInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The plain-text password for the user logging in."
    password: String!
    "The username used for login. Typically a unique or email address depending on specific configuration"
    username: String!
}

"Input for the loginWithCookies mutation"
input LoginWithCookiesInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Input your user/e-mail."
    login: String!
    "Input your password."
    password: String!
    "Whether to \"remember\" the user. Increases the time that the cookie will be kept. Default false."
    rememberMe: Boolean
}

"Input for the logout mutation"
input LogoutInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
}

"Arguments for filtering the MediaItemToCommentConnection connection"
input MediaItemToCommentConnectionWhereArgs {
    "Comment author email address."
    authorEmail: String
    "Array of author IDs to include comments for."
    authorIn: [ID]
    "Array of author IDs to exclude comments for."
    authorNotIn: [ID]
    "Comment author URL."
    authorUrl: String
    "Array of comment IDs to include."
    commentIn: [ID]
    "Array of IDs of users whose unapproved comments will be returned by the query regardless of status."
    commentNotIn: [ID]
    "Include comments of a given type."
    commentType: String
    "Include comments from a given array of comment types."
    commentTypeIn: [String]
    "Exclude comments from a given array of comment types."
    commentTypeNotIn: String
    "Content object author ID to limit results by."
    contentAuthor: [ID]
    "Array of author IDs to retrieve comments for."
    contentAuthorIn: [ID]
    "Array of author IDs *not* to retrieve comments for."
    contentAuthorNotIn: [ID]
    "Limit results to those affiliated with a given content object ID."
    contentId: ID
    "Array of content object IDs to include affiliated comments for."
    contentIdIn: [ID]
    "Array of content object IDs to exclude affiliated comments for."
    contentIdNotIn: [ID]
    "Content object name to retrieve affiliated comments for."
    contentName: String
    "Content Object parent ID to retrieve affiliated comments for."
    contentParent: Int
    "Array of content object statuses to retrieve affiliated comments for. Pass 'any' to match any value."
    contentStatus: [PostStatusEnum]
    "Content object type or array of types to retrieve affiliated comments for. Pass 'any' to match any value."
    contentType: [ContentTypeEnum]
    "Array of IDs or email addresses of users whose unapproved comments will be returned by the query regardless of $status. Default empty"
    includeUnapproved: [ID]
    "Karma score to retrieve matching comments for."
    karma: Int
    "The cardinality of the order of the connection"
    order: OrderEnum
    "Field to order the comments by."
    orderby: CommentsConnectionOrderbyEnum
    "Parent ID of comment to retrieve children of."
    parent: Int
    "Array of parent IDs of comments to retrieve children for."
    parentIn: [ID]
    "Array of parent IDs of comments *not* to retrieve children for."
    parentNotIn: [ID]
    "Search term(s) to retrieve matching comments for."
    search: String
    "Comment status to limit results by."
    status: String
    "Include comments for a specific user ID."
    userId: ID
}

"Arguments for filtering the MenuItemToMenuItemConnection connection"
input MenuItemToMenuItemConnectionWhereArgs {
    "The ID of the object"
    id: Int
    "The menu location for the menu being queried"
    location: MenuLocationEnum
    "The database ID of the parent menu object"
    parentDatabaseId: Int
    "The ID of the parent menu object"
    parentId: ID
}

"Arguments for filtering the MenuToMenuItemConnection connection"
input MenuToMenuItemConnectionWhereArgs {
    "The ID of the object"
    id: Int
    "The menu location for the menu being queried"
    location: MenuLocationEnum
    "The database ID of the parent menu object"
    parentDatabaseId: Int
    "The ID of the parent menu object"
    parentId: ID
}

"Arguments for filtering the PageToCommentConnection connection"
input PageToCommentConnectionWhereArgs {
    "Comment author email address."
    authorEmail: String
    "Array of author IDs to include comments for."
    authorIn: [ID]
    "Array of author IDs to exclude comments for."
    authorNotIn: [ID]
    "Comment author URL."
    authorUrl: String
    "Array of comment IDs to include."
    commentIn: [ID]
    "Array of IDs of users whose unapproved comments will be returned by the query regardless of status."
    commentNotIn: [ID]
    "Include comments of a given type."
    commentType: String
    "Include comments from a given array of comment types."
    commentTypeIn: [String]
    "Exclude comments from a given array of comment types."
    commentTypeNotIn: String
    "Content object author ID to limit results by."
    contentAuthor: [ID]
    "Array of author IDs to retrieve comments for."
    contentAuthorIn: [ID]
    "Array of author IDs *not* to retrieve comments for."
    contentAuthorNotIn: [ID]
    "Limit results to those affiliated with a given content object ID."
    contentId: ID
    "Array of content object IDs to include affiliated comments for."
    contentIdIn: [ID]
    "Array of content object IDs to exclude affiliated comments for."
    contentIdNotIn: [ID]
    "Content object name to retrieve affiliated comments for."
    contentName: String
    "Content Object parent ID to retrieve affiliated comments for."
    contentParent: Int
    "Array of content object statuses to retrieve affiliated comments for. Pass 'any' to match any value."
    contentStatus: [PostStatusEnum]
    "Content object type or array of types to retrieve affiliated comments for. Pass 'any' to match any value."
    contentType: [ContentTypeEnum]
    "Array of IDs or email addresses of users whose unapproved comments will be returned by the query regardless of $status. Default empty"
    includeUnapproved: [ID]
    "Karma score to retrieve matching comments for."
    karma: Int
    "The cardinality of the order of the connection"
    order: OrderEnum
    "Field to order the comments by."
    orderby: CommentsConnectionOrderbyEnum
    "Parent ID of comment to retrieve children of."
    parent: Int
    "Array of parent IDs of comments to retrieve children for."
    parentIn: [ID]
    "Array of parent IDs of comments *not* to retrieve children for."
    parentNotIn: [ID]
    "Search term(s) to retrieve matching comments for."
    search: String
    "Comment status to limit results by."
    status: String
    "Include comments for a specific user ID."
    userId: ID
}

"Arguments for filtering the pageToRevisionConnection connection"
input PageToRevisionConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Set relationships between the post to categories"
input PostCategoriesInput {
    "If true, this will append the category to existing related categories. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [PostCategoriesNodeInput]
}

"List of categories to connect the post to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input PostCategoriesNodeInput {
    "The description of the category. This field is used to set a description of the category if a new one is created during the mutation."
    description: String
    "The ID of the category. If present, this will be used to connect to the post. If no existing category exists with this ID, no connection will be made."
    id: ID
    "The name of the category. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the category. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Arguments for filtering the PostFormatToContentNodeConnection connection"
input PostFormatToContentNodeConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypesOfPostFormatEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the PostFormatToPostConnection connection"
input PostFormatToPostConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the PostFormatToProductConnection connection"
input PostFormatToProductConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Options for ordering the connection"
input PostObjectsConnectionOrderbyInput {
    "The field to order the connection by"
    field: PostObjectsConnectionOrderbyEnum!
    "Possible directions in which to order a list of items"
    order: OrderEnum!
}

"Set relationships between the post to postFormats"
input PostPostFormatsInput {
    "If true, this will append the postFormat to existing related postFormats. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [PostPostFormatsNodeInput]
}

"List of postFormats to connect the post to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input PostPostFormatsNodeInput {
    "The description of the postFormat. This field is used to set a description of the postFormat if a new one is created during the mutation."
    description: String
    "The ID of the postFormat. If present, this will be used to connect to the post. If no existing postFormat exists with this ID, no connection will be made."
    id: ID
    "The name of the postFormat. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the postFormat. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Set relationships between the post to tags"
input PostTagsInput {
    "If true, this will append the tag to existing related tags. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [PostTagsNodeInput]
}

"List of tags to connect the post to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input PostTagsNodeInput {
    "The description of the tag. This field is used to set a description of the tag if a new one is created during the mutation."
    description: String
    "The ID of the tag. If present, this will be used to connect to the post. If no existing tag exists with this ID, no connection will be made."
    id: ID
    "The name of the tag. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the tag. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Arguments for filtering the PostToCategoryConnection connection"
input PostToCategoryConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the PostToCommentConnection connection"
input PostToCommentConnectionWhereArgs {
    "Comment author email address."
    authorEmail: String
    "Array of author IDs to include comments for."
    authorIn: [ID]
    "Array of author IDs to exclude comments for."
    authorNotIn: [ID]
    "Comment author URL."
    authorUrl: String
    "Array of comment IDs to include."
    commentIn: [ID]
    "Array of IDs of users whose unapproved comments will be returned by the query regardless of status."
    commentNotIn: [ID]
    "Include comments of a given type."
    commentType: String
    "Include comments from a given array of comment types."
    commentTypeIn: [String]
    "Exclude comments from a given array of comment types."
    commentTypeNotIn: String
    "Content object author ID to limit results by."
    contentAuthor: [ID]
    "Array of author IDs to retrieve comments for."
    contentAuthorIn: [ID]
    "Array of author IDs *not* to retrieve comments for."
    contentAuthorNotIn: [ID]
    "Limit results to those affiliated with a given content object ID."
    contentId: ID
    "Array of content object IDs to include affiliated comments for."
    contentIdIn: [ID]
    "Array of content object IDs to exclude affiliated comments for."
    contentIdNotIn: [ID]
    "Content object name to retrieve affiliated comments for."
    contentName: String
    "Content Object parent ID to retrieve affiliated comments for."
    contentParent: Int
    "Array of content object statuses to retrieve affiliated comments for. Pass 'any' to match any value."
    contentStatus: [PostStatusEnum]
    "Content object type or array of types to retrieve affiliated comments for. Pass 'any' to match any value."
    contentType: [ContentTypeEnum]
    "Array of IDs or email addresses of users whose unapproved comments will be returned by the query regardless of $status. Default empty"
    includeUnapproved: [ID]
    "Karma score to retrieve matching comments for."
    karma: Int
    "The cardinality of the order of the connection"
    order: OrderEnum
    "Field to order the comments by."
    orderby: CommentsConnectionOrderbyEnum
    "Parent ID of comment to retrieve children of."
    parent: Int
    "Array of parent IDs of comments to retrieve children for."
    parentIn: [ID]
    "Array of parent IDs of comments *not* to retrieve children for."
    parentNotIn: [ID]
    "Search term(s) to retrieve matching comments for."
    search: String
    "Comment status to limit results by."
    status: String
    "Include comments for a specific user ID."
    userId: ID
}

"Arguments for filtering the PostToPostFormatConnection connection"
input PostToPostFormatConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the postToRevisionConnection connection"
input PostToRevisionConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the PostToTagConnection connection"
input PostToTagConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the PostToTermNodeConnection connection"
input PostToTermNodeConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "The Taxonomy to filter terms by"
    taxonomies: [TaxonomyEnum]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Set relationships between the Product to categories"
input ProductCategoriesInput {
    "If true, this will append the category to existing related categories. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [ProductCategoriesNodeInput]
}

"List of categories to connect the Product to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input ProductCategoriesNodeInput {
    "The description of the category. This field is used to set a description of the category if a new one is created during the mutation."
    description: String
    "The ID of the category. If present, this will be used to connect to the Product. If no existing category exists with this ID, no connection will be made."
    id: ID
    "The name of the category. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the category. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Set relationships between the Product to postFormats"
input ProductPostFormatsInput {
    "If true, this will append the postFormat to existing related postFormats. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [ProductPostFormatsNodeInput]
}

"List of postFormats to connect the Product to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input ProductPostFormatsNodeInput {
    "The description of the postFormat. This field is used to set a description of the postFormat if a new one is created during the mutation."
    description: String
    "The ID of the postFormat. If present, this will be used to connect to the Product. If no existing postFormat exists with this ID, no connection will be made."
    id: ID
    "The name of the postFormat. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the postFormat. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Arguments for filtering the ProductToCategoryConnection connection"
input ProductToCategoryConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the ProductToPostFormatConnection connection"
input ProductToPostFormatConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the ProductToTermNodeConnection connection"
input ProductToTermNodeConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "The Taxonomy to filter terms by"
    taxonomies: [TaxonomyEnum]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Input for the refreshJwtAuthToken mutation"
input RefreshJwtAuthTokenInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "A valid, previously issued JWT refresh token. If valid a new Auth token will be provided. If invalid, expired, revoked or otherwise invalid, a new AuthToken will not be provided."
    jwtRefreshToken: String!
}

"Input for the registerUser mutation"
input RegisterUserInput {
    "User's AOL IM account."
    aim: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "A string containing content about the user."
    description: String
    "A string that will be shown on the site. Defaults to user's username. It is likely that you will want to change this, for both appearance and security through obscurity (that is if you dont use and delete the default admin user)."
    displayName: String
    "A string containing the user's email address."
    email: String
    "\tThe user's first name."
    firstName: String
    "User's Jabber account."
    jabber: String
    "The user's last name."
    lastName: String
    "User's locale."
    locale: String
    "A string that contains a URL-friendly name for the user. The default is the user's username."
    nicename: String
    "The user's nickname, defaults to the user's username."
    nickname: String
    "A string that contains the plain text password for the user."
    password: String
    "If true, this will refresh the users JWT secret."
    refreshJwtUserSecret: Boolean
    "The date the user registered. Format is Y-m-d H:i:s."
    registered: String
    "If true, this will revoke the users JWT secret. If false, this will unrevoke the JWT secret AND issue a new one. To revoke, the user must have proper capabilities to edit users JWT secrets."
    revokeJwtUserSecret: Boolean
    "A string for whether to enable the rich editor or not. False if not empty."
    richEditing: String
    "A string that contains the user's username."
    username: String!
    "A string containing the user's URL for the user's web site."
    websiteUrl: String
    "User's Yahoo IM account."
    yim: String
}

"Input for the removeFromWishlist mutation"
input RemoveFromWishlistInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Product id"
    productId: Int
}

"Input for the resetUserPassword mutation"
input ResetUserPasswordInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Password reset key"
    key: String
    "The user's login (username)."
    login: String
    "The new password."
    password: String
}

"Set relationships between the ResourceLibrary to categories"
input ResourceLibraryCategoriesInput {
    "If true, this will append the category to existing related categories. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [ResourceLibraryCategoriesNodeInput]
}

"List of categories to connect the ResourceLibrary to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input ResourceLibraryCategoriesNodeInput {
    "The description of the category. This field is used to set a description of the category if a new one is created during the mutation."
    description: String
    "The ID of the category. If present, this will be used to connect to the ResourceLibrary. If no existing category exists with this ID, no connection will be made."
    id: ID
    "The name of the category. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the category. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Set relationships between the ResourceLibrary to subCategories"
input ResourceLibrarySubCategoriesInput {
    "If true, this will append the subCategory to existing related subCategories. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [ResourceLibrarySubCategoriesNodeInput]
}

"List of subCategories to connect the ResourceLibrary to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input ResourceLibrarySubCategoriesNodeInput {
    "The description of the subCategory. This field is used to set a description of the subCategory if a new one is created during the mutation."
    description: String
    "The ID of the subCategory. If present, this will be used to connect to the ResourceLibrary. If no existing subCategory exists with this ID, no connection will be made."
    id: ID
    "The name of the subCategory. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the subCategory. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Set relationships between the ResourceLibrary to tags"
input ResourceLibraryTagsInput {
    "If true, this will append the tag to existing related tags. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [ResourceLibraryTagsNodeInput]
}

"List of tags to connect the ResourceLibrary to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input ResourceLibraryTagsNodeInput {
    "The description of the tag. This field is used to set a description of the tag if a new one is created during the mutation."
    description: String
    "The ID of the tag. If present, this will be used to connect to the ResourceLibrary. If no existing tag exists with this ID, no connection will be made."
    id: ID
    "The name of the tag. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the tag. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Arguments for filtering the ResourceLibraryToCategoryConnection connection"
input ResourceLibraryToCategoryConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the ResourceLibraryToSubCategoryConnection connection"
input ResourceLibraryToSubCategoryConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the ResourceLibraryToTagConnection connection"
input ResourceLibraryToTagConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the ResourceLibraryToTermNodeConnection connection"
input ResourceLibraryToTermNodeConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "The Taxonomy to filter terms by"
    taxonomies: [TaxonomyEnum]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Input for the restoreComment mutation"
input RestoreCommentInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The ID of the comment to be restored"
    id: ID!
}

"Arguments for filtering the RootQueryToCategoryConnection connection"
input RootQueryToCategoryConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the RootQueryToCommentConnection connection"
input RootQueryToCommentConnectionWhereArgs {
    "Comment author email address."
    authorEmail: String
    "Array of author IDs to include comments for."
    authorIn: [ID]
    "Array of author IDs to exclude comments for."
    authorNotIn: [ID]
    "Comment author URL."
    authorUrl: String
    "Array of comment IDs to include."
    commentIn: [ID]
    "Array of IDs of users whose unapproved comments will be returned by the query regardless of status."
    commentNotIn: [ID]
    "Include comments of a given type."
    commentType: String
    "Include comments from a given array of comment types."
    commentTypeIn: [String]
    "Exclude comments from a given array of comment types."
    commentTypeNotIn: String
    "Content object author ID to limit results by."
    contentAuthor: [ID]
    "Array of author IDs to retrieve comments for."
    contentAuthorIn: [ID]
    "Array of author IDs *not* to retrieve comments for."
    contentAuthorNotIn: [ID]
    "Limit results to those affiliated with a given content object ID."
    contentId: ID
    "Array of content object IDs to include affiliated comments for."
    contentIdIn: [ID]
    "Array of content object IDs to exclude affiliated comments for."
    contentIdNotIn: [ID]
    "Content object name to retrieve affiliated comments for."
    contentName: String
    "Content Object parent ID to retrieve affiliated comments for."
    contentParent: Int
    "Array of content object statuses to retrieve affiliated comments for. Pass 'any' to match any value."
    contentStatus: [PostStatusEnum]
    "Content object type or array of types to retrieve affiliated comments for. Pass 'any' to match any value."
    contentType: [ContentTypeEnum]
    "Array of IDs or email addresses of users whose unapproved comments will be returned by the query regardless of $status. Default empty"
    includeUnapproved: [ID]
    "Karma score to retrieve matching comments for."
    karma: Int
    "The cardinality of the order of the connection"
    order: OrderEnum
    "Field to order the comments by."
    orderby: CommentsConnectionOrderbyEnum
    "Parent ID of comment to retrieve children of."
    parent: Int
    "Array of parent IDs of comments to retrieve children for."
    parentIn: [ID]
    "Array of parent IDs of comments *not* to retrieve children for."
    parentNotIn: [ID]
    "Search term(s) to retrieve matching comments for."
    search: String
    "Comment status to limit results by."
    status: String
    "Include comments for a specific user ID."
    userId: ID
}

"Arguments for filtering the RootQueryToContentNodeConnection connection"
input RootQueryToContentNodeConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypeEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToContentRevisionUnionConnection connection"
input RootQueryToContentRevisionUnionConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypeEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToCourseConnection connection"
input RootQueryToCourseConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToDownloadFreebieConnection connection"
input RootQueryToDownloadFreebieConnectionWhereArgs {
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToDownloadGridConnection connection"
input RootQueryToDownloadGridConnectionWhereArgs {
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToMediaItemConnection connection"
input RootQueryToMediaItemConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToMenuConnection connection"
input RootQueryToMenuConnectionWhereArgs {
    "The ID of the object"
    id: Int
    "The menu location for the menu being queried"
    location: MenuLocationEnum
    "The slug of the menu to query items for"
    slug: String
}

"Arguments for filtering the RootQueryToMenuItemConnection connection"
input RootQueryToMenuItemConnectionWhereArgs {
    "The ID of the object"
    id: Int
    "The menu location for the menu being queried"
    location: MenuLocationEnum
    "The database ID of the parent menu object"
    parentDatabaseId: Int
    "The ID of the parent menu object"
    parentId: ID
}

"Arguments for filtering the RootQueryToPageConnection connection"
input RootQueryToPageConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToPluginConnection connection"
input RootQueryToPluginConnectionWhereArgs {
    "Show plugin based on a keyword search."
    search: String
    "Retrieve plugins where plugin status is in an array."
    stati: [PluginStatusEnum]
    "Show plugins with a specific status."
    status: PluginStatusEnum
}

"Arguments for filtering the RootQueryToPostConnection connection"
input RootQueryToPostConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "The ID of the post object to filter by"
    onlySticky: Boolean
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToPostFormatConnection connection"
input RootQueryToPostFormatConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the RootQueryToProductConnection connection"
input RootQueryToProductConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToResourceLibraryConnection connection"
input RootQueryToResourceLibraryConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToSubCategoryConnection connection"
input RootQueryToSubCategoryConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the RootQueryToTagConnection connection"
input RootQueryToTagConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the RootQueryToTermNodeConnection connection"
input RootQueryToTermNodeConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "The Taxonomy to filter terms by"
    taxonomies: [TaxonomyEnum]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the RootQueryToThingILoveConnection connection"
input RootQueryToThingILoveConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the RootQueryToUserConnection connection"
input RootQueryToUserConnectionWhereArgs {
    "Array of userIds to exclude."
    exclude: [Int]
    "Pass an array of post types to filter results to users who have published posts in those post types."
    hasPublishedPosts: [ContentTypeEnum]
    "Array of userIds to include."
    include: [Int]
    "The user login."
    login: String
    "An array of logins to include. Users matching one of these logins will be included in results."
    loginIn: [String]
    "An array of logins to exclude. Users matching one of these logins will not be included in results."
    loginNotIn: [String]
    "The user nicename."
    nicename: String
    "An array of nicenames to include. Users matching one of these nicenames will be included in results."
    nicenameIn: [String]
    "An array of nicenames to exclude. Users matching one of these nicenames will not be included in results."
    nicenameNotIn: [String]
    "What paramater to use to order the objects by."
    orderby: [UsersConnectionOrderbyInput]
    "An array of role names that users must match to be included in results. Note that this is an inclusive list: users must match *each* role."
    role: UserRoleEnum
    "An array of role names. Matched users must have at least one of these roles."
    roleIn: [UserRoleEnum]
    "An array of role names to exclude. Users matching one or more of these roles will not be included in results."
    roleNotIn: [UserRoleEnum]
    "Search keyword. Searches for possible string matches on columns. When \"searchColumns\" is left empty, it tries to determine which column to search in based on search string."
    search: String
    "Array of column names to be searched. Accepts 'ID', 'login', 'nicename', 'email', 'url'."
    searchColumns: [UsersConnectionSearchColumnEnum]
}

"Input for the sendEmail mutation"
input SendEmailInput {
    "Body of email"
    body: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Who to send the email from"
    from: String
    "Name of person"
    name: String
    "Reply to address"
    replyTo: String
    "Subject of email"
    subject: String
    "Who to send the email to"
    to: String
}

"Input for the sendPasswordResetEmail mutation"
input SendPasswordResetEmailInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "A string that contains the user's username or email address."
    username: String!
}

"Arguments for filtering the SubCategoryToContentNodeConnection connection"
input SubCategoryToContentNodeConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypesOfSubCategoryEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the SubCategoryToResourceLibraryConnection connection"
input SubCategoryToResourceLibraryConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the TagToContentNodeConnection connection"
input TagToContentNodeConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypesOfTagEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the TagToCourseConnection connection"
input TagToCourseConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the TagToDownloadGridConnection connection"
input TagToDownloadGridConnectionWhereArgs {
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the TagToPostConnection connection"
input TagToPostConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Arguments for filtering the TagToResourceLibraryConnection connection"
input TagToResourceLibraryConnectionWhereArgs {
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Set relationships between the ThingILove to categories"
input ThingILoveCategoriesInput {
    "If true, this will append the category to existing related categories. If false, this will replace existing relationships. Default true."
    append: Boolean
    "The input list of items to set."
    nodes: [ThingILoveCategoriesNodeInput]
}

"List of categories to connect the ThingILove to. If an ID is set, it will be used to create the connection. If not, it will look for a slug. If neither are valid existing terms, and the site is configured to allow terms to be created during post mutations, a term will be created using the Name if it exists in the input, then fallback to the slug if it exists."
input ThingILoveCategoriesNodeInput {
    "The description of the category. This field is used to set a description of the category if a new one is created during the mutation."
    description: String
    "The ID of the category. If present, this will be used to connect to the ThingILove. If no existing category exists with this ID, no connection will be made."
    id: ID
    "The name of the category. This field is used to create a new term, if term creation is enabled in nested mutations, and if one does not already exist with the provided slug or ID or if a slug or ID is not provided. If no name is included and a term is created, the creation will fallback to the slug field."
    name: String
    "The slug of the category. If no ID is present, this field will be used to make a connection. If no existing term exists with this slug, this field will be used as a fallback to the Name field when creating a new term to connect to, if term creation is enabled as a nested mutation."
    slug: String
}

"Arguments for filtering the ThingILoveToCategoryConnection connection"
input ThingILoveToCategoryConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Arguments for filtering the ThingILoveToTermNodeConnection connection"
input ThingILoveToTermNodeConnectionWhereArgs {
    "Unique cache key to be produced when this query is stored in an object cache. Default is 'core'."
    cacheDomain: String
    "Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0."
    childOf: Int
    "True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false."
    childless: Boolean
    "Retrieve terms where the description is LIKE the input value. Default empty."
    descriptionLike: String
    "Array of term ids to exclude. If $include is non-empty, $exclude is ignored. Default empty array."
    exclude: [ID]
    "Array of term ids to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array."
    excludeTree: [ID]
    "Whether to hide terms not assigned to any posts. Accepts true or false. Default false"
    hideEmpty: Boolean
    "Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true."
    hierarchical: Boolean
    "Array of term ids to include. Default empty array."
    include: [ID]
    "Array of names to return term(s) for. Default empty."
    name: [String]
    "Retrieve terms where the name is LIKE the input value. Default empty."
    nameLike: String
    "Array of object IDs. Results will be limited to terms associated with these objects."
    objectIds: [ID]
    "Direction the connection should be ordered in"
    order: OrderEnum
    "Field(s) to order terms by. Defaults to 'name'."
    orderby: TermObjectsConnectionOrderbyEnum
    "Whether to pad the quantity of a term's children in the quantity of each term's \"count\" object variable. Default false."
    padCounts: Boolean
    "Parent term ID to retrieve direct-child terms of. Default empty."
    parent: Int
    "Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty."
    search: String
    "Array of slugs to return term(s) for. Default empty."
    slug: [String]
    "The Taxonomy to filter terms by"
    taxonomies: [TaxonomyEnum]
    "Array of term taxonomy IDs, to match when querying terms."
    termTaxonomId: [ID]
    "Whether to prime meta caches for matched terms. Default true."
    updateTermMetaCache: Boolean
}

"Input for the UpdateCategory mutation"
input UpdateCategoryInput {
    "The slug that the category will be an alias of"
    aliasOf: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The description of the category object"
    description: String
    "The ID of the category object to update"
    id: ID!
    "The name of the category object to mutate"
    name: String
    "The ID of the category that should be set as the parent"
    parentId: ID
    "If this argument exists then the slug will be checked to see if it is not an existing valid term. If that check succeeds (it is not a valid term), then it is added and the term id is given. If it fails, then a check is made to whether the taxonomy is hierarchical and the parent argument is not empty. If the second check succeeds, the term will be inserted and the term id will be given. If the slug argument is empty, then it will be calculated from the term name."
    slug: String
}

"Input for the updateComment mutation"
input UpdateCommentInput {
    "The approval status of the comment."
    approved: String
    "The name of the comment's author."
    author: String
    "The email of the comment's author."
    authorEmail: String
    "The url of the comment's author."
    authorUrl: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The database ID of the post object the comment belongs to."
    commentOn: Int
    "Content of the comment."
    content: String
    "The date of the object. Preferable to enter as year/month/day ( e.g. 01/31/2017 ) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The ID of the comment being updated."
    id: ID!
    "Parent comment ID of current comment."
    parent: ID
    "Type of comment."
    type: String
}

"Input for the updateCourse mutation"
input UpdateCourseInput {
    "Set connections between the Course and categories"
    categories: CourseCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The content of the object"
    content: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The ID of the Course object"
    id: ID!
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "Set connections between the Course and tags"
    tags: CourseTagsInput
    "The title of the object"
    title: String
}

"Input for the updateDownloadFreebie mutation"
input UpdateDownloadFreebieInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The ID of the downloadFreebie object"
    id: ID!
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "The title of the object"
    title: String
}

"Input for the updateDownloadGrid mutation"
input UpdateDownloadGridInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The ID of the DownloadGrid object"
    id: ID!
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "Set connections between the DownloadGrid and tags"
    tags: DownloadGridTagsInput
    "The title of the object"
    title: String
}

"Input for the updateMediaItem mutation"
input UpdateMediaItemInput {
    "Alternative text to display when mediaItem is not displayed"
    altText: String
    "The userId to assign as the author of the mediaItem"
    authorId: ID
    "The caption for the mediaItem"
    caption: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The comment status for the mediaItem"
    commentStatus: String
    "The date of the mediaItem"
    date: String
    "The date (in GMT zone) of the mediaItem"
    dateGmt: String
    "Description of the mediaItem"
    description: String
    "The file name of the mediaItem"
    filePath: String
    "The file type of the mediaItem"
    fileType: MimeTypeEnum
    "The ID of the mediaItem object"
    id: ID!
    "The ID of the parent object"
    parentId: ID
    "The ping status for the mediaItem"
    pingStatus: String
    "The slug of the mediaItem"
    slug: String
    "The status of the mediaItem"
    status: MediaItemStatusEnum
    "The title of the mediaItem"
    title: String
}

"Input for the updatePage mutation"
input UpdatePageInput {
    "The userId to assign as the author of the object"
    authorId: ID
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The comment status for the object"
    commentStatus: String
    "The content of the object"
    content: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The ID of the page object"
    id: ID!
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The ID of the parent object"
    parentId: ID
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "The title of the object"
    title: String
}

"Input for the UpdatePostFormat mutation"
input UpdatePostFormatInput {
    "The slug that the post_format will be an alias of"
    aliasOf: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The description of the post_format object"
    description: String
    "The ID of the postFormat object to update"
    id: ID!
    "The name of the post_format object to mutate"
    name: String
    "If this argument exists then the slug will be checked to see if it is not an existing valid term. If that check succeeds (it is not a valid term), then it is added and the term id is given. If it fails, then a check is made to whether the taxonomy is hierarchical and the parent argument is not empty. If the second check succeeds, the term will be inserted and the term id will be given. If the slug argument is empty, then it will be calculated from the term name."
    slug: String
}

"Input for the updatePost mutation"
input UpdatePostInput {
    "The userId to assign as the author of the object"
    authorId: ID
    "Set connections between the post and categories"
    categories: PostCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The comment status for the object"
    commentStatus: String
    "The content of the object"
    content: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The excerpt of the object"
    excerpt: String
    "The ID of the post object"
    id: ID!
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The ping status for the object"
    pingStatus: String
    "URLs that have been pinged."
    pinged: [String]
    "Set connections between the post and postFormats"
    postFormats: PostPostFormatsInput
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "Set connections between the post and tags"
    tags: PostTagsInput
    "The title of the object"
    title: String
    "URLs queued to be pinged."
    toPing: [String]
}

"Input for the updateProduct mutation"
input UpdateProductInput {
    "Set connections between the Product and categories"
    categories: ProductCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The ID of the Product object"
    id: ID!
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "Set connections between the Product and postFormats"
    postFormats: ProductPostFormatsInput
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "The title of the object"
    title: String
}

"Input for the updateResourceLibrary mutation"
input UpdateResourceLibraryInput {
    "Set connections between the ResourceLibrary and categories"
    categories: ResourceLibraryCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The ID of the ResourceLibrary object"
    id: ID!
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "Set connections between the ResourceLibrary and subCategories"
    subCategories: ResourceLibrarySubCategoriesInput
    "Set connections between the ResourceLibrary and tags"
    tags: ResourceLibraryTagsInput
    "The title of the object"
    title: String
}

"Input for the updateSettings mutation"
input UpdateSettingsInput {
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "Allow people to submit comments on new posts."
    discussionSettingsDefaultCommentStatus: String
    "Allow link notifications from other blogs (pingbacks and trackbacks) on new articles."
    discussionSettingsDefaultPingStatus: String
    "A date format for all date strings."
    generalSettingsDateFormat: String
    "Site tagline."
    generalSettingsDescription: String
    "This address is used for admin purposes, like new user notification."
    generalSettingsEmail: String
    "WordPress locale code."
    generalSettingsLanguage: String
    "A day number of the week that the week should start on."
    generalSettingsStartOfWeek: Int
    "A time format for all time strings."
    generalSettingsTimeFormat: String
    "A city in the same timezone as you."
    generalSettingsTimezone: String
    "Site title."
    generalSettingsTitle: String
    "Site URL."
    generalSettingsUrl: String
    "Blog pages show at most."
    readingSettingsPostsPerPage: Int
    "Default post category."
    writingSettingsDefaultCategory: Int
    "Default post format."
    writingSettingsDefaultPostFormat: String
    "Convert emoticons like :-) and :-P to graphics on display."
    writingSettingsUseSmilies: Boolean
}

"Input for the UpdateSubCategory mutation"
input UpdateSubCategoryInput {
    "The slug that the subcategory will be an alias of"
    aliasOf: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The description of the subcategory object"
    description: String
    "The ID of the subCategory object to update"
    id: ID!
    "The name of the subcategory object to mutate"
    name: String
    "If this argument exists then the slug will be checked to see if it is not an existing valid term. If that check succeeds (it is not a valid term), then it is added and the term id is given. If it fails, then a check is made to whether the taxonomy is hierarchical and the parent argument is not empty. If the second check succeeds, the term will be inserted and the term id will be given. If the slug argument is empty, then it will be calculated from the term name."
    slug: String
}

"Input for the UpdateTag mutation"
input UpdateTagInput {
    "The slug that the post_tag will be an alias of"
    aliasOf: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The description of the post_tag object"
    description: String
    "The ID of the tag object to update"
    id: ID!
    "The name of the post_tag object to mutate"
    name: String
    "If this argument exists then the slug will be checked to see if it is not an existing valid term. If that check succeeds (it is not a valid term), then it is added and the term id is given. If it fails, then a check is made to whether the taxonomy is hierarchical and the parent argument is not empty. If the second check succeeds, the term will be inserted and the term id will be given. If the slug argument is empty, then it will be calculated from the term name."
    slug: String
}

"Input for the updateThingILove mutation"
input UpdateThingILoveInput {
    "Set connections between the ThingILove and categories"
    categories: ThingILoveCategoriesInput
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "The date of the object. Preferable to enter as year/month/day (e.g. 01/31/2017) as it will rearrange date as fit if it is not specified. Incomplete dates may have unintended results for example, \"2017\" as the input will use current date with timestamp 20:17 "
    date: String
    "The ID of the ThingILove object"
    id: ID!
    "A field used for ordering posts. This is typically used with nav menu items or for special ordering of hierarchical content types."
    menuOrder: Int
    "The password used to protect the content of the object"
    password: String
    "The slug of the object"
    slug: String
    "The status of the object"
    status: PostStatusEnum
    "The title of the object"
    title: String
}

"Input for the updateUser mutation"
input UpdateUserInput {
    "User's AOL IM account."
    aim: String
    "This is an ID that can be passed to a mutation by the client to track the progress of mutations and catch possible duplicate mutation submissions."
    clientMutationId: String
    "A string containing content about the user."
    description: String
    "A string that will be shown on the site. Defaults to user's username. It is likely that you will want to change this, for both appearance and security through obscurity (that is if you dont use and delete the default admin user)."
    displayName: String
    "A string containing the user's email address."
    email: String
    "\tThe user's first name."
    firstName: String
    "The ID of the user"
    id: ID!
    "User's Jabber account."
    jabber: String
    "The user's last name."
    lastName: String
    "User's locale."
    locale: String
    "A string that contains a URL-friendly name for the user. The default is the user's username."
    nicename: String
    "The user's nickname, defaults to the user's username."
    nickname: String
    "A string that contains the plain text password for the user."
    password: String
    "If true, this will refresh the users JWT secret."
    refreshJwtUserSecret: Boolean
    "The date the user registered. Format is Y-m-d H:i:s."
    registered: String
    "If true, this will revoke the users JWT secret. If false, this will unrevoke the JWT secret AND issue a new one. To revoke, the user must have proper capabilities to edit users JWT secrets."
    revokeJwtUserSecret: Boolean
    "A string for whether to enable the rich editor or not. False if not empty."
    richEditing: String
    "An array of roles to be assigned to the user."
    roles: [String]
    "A string containing the user's URL for the user's web site."
    websiteUrl: String
    "User's Yahoo IM account."
    yim: String
}

"Arguments for filtering the UserToCommentConnection connection"
input UserToCommentConnectionWhereArgs {
    "Comment author email address."
    authorEmail: String
    "Array of author IDs to include comments for."
    authorIn: [ID]
    "Array of author IDs to exclude comments for."
    authorNotIn: [ID]
    "Comment author URL."
    authorUrl: String
    "Array of comment IDs to include."
    commentIn: [ID]
    "Array of IDs of users whose unapproved comments will be returned by the query regardless of status."
    commentNotIn: [ID]
    "Include comments of a given type."
    commentType: String
    "Include comments from a given array of comment types."
    commentTypeIn: [String]
    "Exclude comments from a given array of comment types."
    commentTypeNotIn: String
    "Content object author ID to limit results by."
    contentAuthor: [ID]
    "Array of author IDs to retrieve comments for."
    contentAuthorIn: [ID]
    "Array of author IDs *not* to retrieve comments for."
    contentAuthorNotIn: [ID]
    "Limit results to those affiliated with a given content object ID."
    contentId: ID
    "Array of content object IDs to include affiliated comments for."
    contentIdIn: [ID]
    "Array of content object IDs to exclude affiliated comments for."
    contentIdNotIn: [ID]
    "Content object name to retrieve affiliated comments for."
    contentName: String
    "Content Object parent ID to retrieve affiliated comments for."
    contentParent: Int
    "Array of content object statuses to retrieve affiliated comments for. Pass 'any' to match any value."
    contentStatus: [PostStatusEnum]
    "Content object type or array of types to retrieve affiliated comments for. Pass 'any' to match any value."
    contentType: [ContentTypeEnum]
    "Array of IDs or email addresses of users whose unapproved comments will be returned by the query regardless of $status. Default empty"
    includeUnapproved: [ID]
    "Karma score to retrieve matching comments for."
    karma: Int
    "The cardinality of the order of the connection"
    order: OrderEnum
    "Field to order the comments by."
    orderby: CommentsConnectionOrderbyEnum
    "Parent ID of comment to retrieve children of."
    parent: Int
    "Array of parent IDs of comments to retrieve children for."
    parentIn: [ID]
    "Array of parent IDs of comments *not* to retrieve children for."
    parentNotIn: [ID]
    "Search term(s) to retrieve matching comments for."
    search: String
    "Comment status to limit results by."
    status: String
    "Include comments for a specific user ID."
    userId: ID
}

"Arguments for filtering the UserToContentRevisionUnionConnection connection"
input UserToContentRevisionUnionConnectionWhereArgs {
    "The Types of content to filter"
    contentTypes: [ContentTypeEnum]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the UserToMediaItemConnection connection"
input UserToMediaItemConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the UserToPageConnection connection"
input UserToPageConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Title of the object"
    title: String
}

"Arguments for filtering the UserToPostConnection connection"
input UserToPostConnectionWhereArgs {
    "The user that's connected as the author of the object. Use the userId for the author object."
    author: Int
    "Find objects connected to author(s) in the array of author's userIds"
    authorIn: [ID]
    "Find objects connected to the author by the author's nicename"
    authorName: String
    "Find objects NOT connected to author(s) in the array of author's userIds"
    authorNotIn: [ID]
    "Category ID"
    categoryId: Int
    "Array of category IDs, used to display objects from one category OR another"
    categoryIn: [ID]
    "Use Category Slug"
    categoryName: String
    "Array of category IDs, used to display objects from one category OR another"
    categoryNotIn: [ID]
    "Filter the connection based on dates"
    dateQuery: DateQueryInput
    "True for objects with passwords; False for objects without passwords; null for all objects with or without passwords"
    hasPassword: Boolean
    "Specific ID of the object"
    id: Int
    "Array of IDs for the objects to retrieve"
    in: [ID]
    "Get objects with a specific mimeType property"
    mimeType: MimeTypeEnum
    "Slug / post_name of the object"
    name: String
    "Specify objects to retrieve. Use slugs"
    nameIn: [String]
    "Specify IDs NOT to retrieve. If this is used in the same query as \"in\", it will be ignored"
    notIn: [ID]
    "What paramater to use to order the objects by."
    orderby: [PostObjectsConnectionOrderbyInput]
    "Use ID to return only children. Use 0 to return only top-level items"
    parent: ID
    "Specify objects whose parent is in an array"
    parentIn: [ID]
    "Specify posts whose parent is not in an array"
    parentNotIn: [ID]
    "Show posts with a specific password."
    password: String
    "Show Posts based on a keyword search"
    search: String
    "Retrieve posts where post status is in an array."
    stati: [PostStatusEnum]
    "Show posts with a specific status."
    status: PostStatusEnum
    "Tag Slug"
    tag: String
    "Use Tag ID"
    tagId: String
    "Array of tag IDs, used to display objects from one tag OR another"
    tagIn: [ID]
    "Array of tag IDs, used to display objects from one tag OR another"
    tagNotIn: [ID]
    "Array of tag slugs, used to display objects from one tag OR another"
    tagSlugAnd: [String]
    "Array of tag slugs, used to exclude objects in specified tags"
    tagSlugIn: [String]
    "Title of the object"
    title: String
}

"Options for ordering the connection"
input UsersConnectionOrderbyInput {
    "The field name used to sort the results."
    field: UsersConnectionOrderbyEnum!
    "The cardinality of the order of the connection"
    order: OrderEnum
}