@seedprotocol/sdk 0.1.47 → 0.1.49

package/dist/src/getModelSchemas.ts

@@ -0,0 +1,88 @@
+import { getModels } from '@/browser/stores/modelClass'
+import { GetSchemasQuery, Schema } from '@/browser/gql/graphql'
+import { getAppDb } from '../sqlWasmClient'
+import { models as modelsTable, modelUids } from '@/shared/seedSchema'
+import { eq } from 'drizzle-orm'
+import pluralize from 'pluralize'
+import { toSnakeCase } from '@/shared/helpers'
+import { easClient, queryClient } from '@/browser/helpers'
+import { GET_SCHEMAS } from '@/browser/item/queries'
+
+type GetModelSchemasReturn = {
+  modelSchemas: GetSchemasQuery
+  schemaStringToModelRecord: Map<string, Schema>
+  modelRecords: Record<string, unknown>
+}
+type GetModelSchemas = () => Promise<GetModelSchemasReturn>
+
+export const getModelSchemas: GetModelSchemas = async () => {
+  const models = getModels()
+  const modelRecords = [] as Record<string, unknown>[]
+
+  const schemaStringToModelRecord = new Map<string, Schema>()
+
+  const appDb = getAppDb()
+
+  const OR: Record<string, unknown>[] = []
+
+  for (const [modelName, _] of Object.entries(models)) {
+    const foundModelQuery = await appDb
+      .select({
+        id: modelsTable.id,
+        name: modelsTable.name,
+        uid: modelUids.uid,
+      })
+      .from(modelsTable)
+      .leftJoin(modelUids, eq(modelsTable.id, modelUids.modelId))
+      .where(eq(modelsTable.name, modelName))
+      .limit(1)
+
+    const foundModel: {
+      id: number
+      name: string
+      uid: string | null
+      tableName?: string
+    } = { ...foundModelQuery[0] }
+
+    if (!foundModel) {
+      console.error(
+        `[item/events] [syncDbWithEas] model ${modelName} not found in SDK DB`,
+      )
+      return
+    }
+
+    foundModel.tableName = pluralize(foundModel.name).toLowerCase()
+
+    modelRecords!.push(foundModel)
+
+    if (modelName === 'Seed' || modelName === 'Version') {
+      continue
+    }
+
+    const schemaString = `bytes32 ${toSnakeCase(modelName)}`
+
+    OR.push({
+      schema: {
+        equals: `bytes32 ${toSnakeCase(modelName)}`,
+      },
+    })
+
+    schemaStringToModelRecord.set(schemaString, foundModel)
+  }
+
+  const modelSchemas = await queryClient.fetchQuery({
+    queryKey: [`getSchemasAllModels`],
+    queryFn: async () =>
+      easClient.request(GET_SCHEMAS, {
+        where: {
+          OR,
+        },
+      }),
+  })
+
+  return {
+    modelSchemas,
+    schemaStringToModelRecord,
+    modelRecords,
+  }
+}

package/dist/src/getSchemaForModel.ts

@@ -0,0 +1,42 @@
+import { EventObject, fromCallback } from 'xstate'
+import {
+  FromCallbackInput,
+  GetSchemaForModelEvent,
+  GlobalMachineContext,
+} from '@/types'
+import debug from 'debug'
+
+const logger = debug('app:services:global:actors:getSchemaForModel')
+
+export const getSchemaForModel = fromCallback<
+  EventObject,
+  FromCallbackInput<GlobalMachineContext, GetSchemaForModelEvent>
+>(({ sendBack, input: { context, event } }) => {
+  const { modelName } = event
+
+  if (!modelName) {
+    console.warn('No modelName found')
+    return
+  }
+
+  const { models } = context
+
+  if (!models) {
+    console.warn('No models found')
+    return
+  }
+
+  const model = Object.entries(models).find(
+    ([modelNameFromConfig]) => modelNameFromConfig === modelName,
+  )
+
+  if (!model) {
+    throw new Error(`Model ${modelName} not found`)
+  }
+
+  logger('[service/actor] [getSchemaForModel] model:', model)
+
+  sendBack({ type: 'schemaForModel', schema: model.schema })
+
+  return () => {}
+})

package/dist/src/getSeedData.ts

@@ -0,0 +1,34 @@
+import { getAppDb } from '../sqlWasmClient'
+import { seeds, SeedType } from '@/shared/seedSchema'
+import { eq } from 'drizzle-orm'
+
+type GetSeedDataProps = {
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type GetSeedData = (props: GetSeedDataProps) => Promise<SeedType | undefined>
+
+export const getSeedData: GetSeedData = async ({ seedLocalId, seedUid }) => {
+  const appDb = getAppDb()
+
+  let query
+
+  const queryBase = appDb.select().from(seeds)
+
+  if (seedLocalId) {
+    query = queryBase.where(eq(seeds.localId, seedLocalId))
+  }
+
+  if (seedUid) {
+    query = queryBase.where(eq(seeds.uid, seedUid))
+  }
+
+  const rows = await query
+
+  if (!rows || !rows.length) {
+    return
+  }
+
+  return rows[0]
+}

package/dist/src/getVersionData.ts

@@ -0,0 +1,58 @@
+import { runQueryForStatement } from '../sqlWasmClient'
+
+type VersionData = {
+  localId: string
+  uid: string
+  seedLocalId: string
+  seedUid: string
+  seedType: string
+  note: string
+  attestationCreatedAt: string
+  attestationRaw: string
+  createdAt: string
+  updatedAt: string
+}
+
+type GetVersionDataProps = {
+  seedLocalId: string
+}
+
+type GetVersionData = (
+  props: GetVersionDataProps,
+) => Promise<VersionData | undefined>
+
+export const getVersionData: GetVersionData = async ({ seedLocalId }) => {
+  const getVersionStatement = `SELECT local_id,
+                                      uid,
+                                      seed_local_id,
+                                      seed_uid,
+                                      seed_type,
+                                      note,
+                                      attestation_created_at,
+                                      attestation_raw,
+                                      created_at,
+                                      updated_at
+                               FROM versions
+                               WHERE local_id = '${seedLocalId}';`
+
+  const { rows } = await runQueryForStatement(getVersionStatement)
+
+  if (!rows || !rows.length) {
+    return
+  }
+
+  const seedValues = rows[0]
+
+  return {
+    localId: seedValues[0],
+    uid: seedValues[1],
+    seedLocalId: seedValues[2],
+    seedUid: seedValues[3],
+    seedType: seedValues[4],
+    note: seedValues[5],
+    attestationCreatedAt: seedValues[6],
+    attestationRaw: seedValues[7],
+    createdAt: seedValues[8],
+    updatedAt: seedValues[9],
+  }
+}

package/dist/src/getVersionsForVersionUids.ts

@@ -0,0 +1,39 @@
+import { runQueryForStatement } from '../sqlWasmClient'
+
+type VersionData = {
+  localId: string
+  uid: string
+  seedUid: string
+  seedLocalId: string
+}
+type GetVersionsForVersionUids = (
+  versionUids: string[],
+) => Promise<VersionData[]>
+export const getVersionsForVersionUids: GetVersionsForVersionUids = async (
+  versionUids: string[],
+) => {
+  const queryStatement = `
+      SELECT local_id, uid, seed_uid, seed_local_id
+      FROM versions
+      WHERE uid IN ('${versionUids.join("','")}');
+  `
+
+  const { rows } = await runQueryForStatement(queryStatement)
+
+  if (!rows || rows.length === 0) {
+    return []
+  }
+
+  const versionsData: VersionData[] = []
+
+  for (const row of rows) {
+    versionsData.push({
+      localId: row[0],
+      uid: row[1],
+      seedUid: row[2],
+      seedLocalId: row[3],
+    })
+  }
+
+  return versionsData
+}

package/dist/src/globalMachine.ts

@@ -0,0 +1,259 @@
+import { ActorRefFrom, assign, createActor, raise, setup } from 'xstate'
+import { createBrowserInspector } from '@statelyai/inspect'
+import {
+  GLOBAL_ADDING_MODELS_TO_DB_SUCCESS,
+  GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES,
+  GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY,
+  GLOBAL_INITIALIZING_SEND_CONFIG,
+  GlobalState,
+  MachineIds,
+} from '@/browser/services/internal/constants'
+import { GlobalMachineContext, ModelClassType } from '@/types'
+import { eventEmitter } from '@/eventBus'
+import { initialize } from '@/browser/services/global/actors/initialize'
+import { getSchemaForModel } from '@/browser/services/global/actors/getSchemaForModel'
+import { addModelsToDb } from '@/browser/services/global/actors/addModelsToDb'
+import { internalMachine } from '@/browser/services/internal/internalMachine'
+import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+import { publishMachine } from '@/browser/services/publish/publishMachine'
+
+const {
+  UNINITIALIZED,
+  INITIALIZING,
+  INITIALIZED,
+  PUBLISHING_ITEM,
+  ADDING_MODELS_TO_DB,
+} = GlobalState
+
+const { inspect } = createBrowserInspector({
+  autoStart: false,
+})
+
+const globalMachine = setup({
+  types: {
+    context: {} as GlobalMachineContext,
+    input: {} as GlobalMachineContext | undefined,
+  },
+  actors: {
+    initialize,
+    addModelsToDb,
+    getSchemaForModel,
+  },
+}).createMachine({
+  id: MachineIds.GLOBAL,
+  initial: UNINITIALIZED,
+  context: ({ input }) => input as GlobalMachineContext,
+  states: {
+    [UNINITIALIZED]: {
+      on: {
+        init: {
+          target: INITIALIZING,
+          guard: ({ context }) => {
+            return typeof window !== 'undefined'
+          },
+          actions: [
+            assign({
+              isInitialized: false,
+              addedModelRecordsToDb: false,
+              models: ({ event }) => event.models,
+              endpoints: ({ event }) => event.endpoints,
+              internalService: ({ spawn, context }) => {
+                return spawn(internalMachine, {
+                  systemId: MachineIds.INTERNAL,
+                  input: {
+                    endpoints: context.endpoints,
+                  },
+                })
+              },
+            }),
+          ],
+        },
+      },
+      meta: {
+        displayText: 'Booting up',
+        percentComplete: 5,
+      },
+      tags: ['loading'],
+    },
+    [INITIALIZING]: {
+      on: {
+        [GLOBAL_INITIALIZING_SEND_CONFIG]: {
+          actions: assign({
+            endpoints: ({ event }) => event.endpoints,
+            environment: ({ event }) => event.environment,
+            addresses: ({ event }) => event.addresses,
+            isInitialized: true,
+          }),
+        },
+        [GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY]: ADDING_MODELS_TO_DB,
+        [GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES]: {
+          actions: [
+            assign(({ event, spawn }) => {
+              const allItemsServices: Record<
+                string,
+                ActorRefFrom<typeof itemMachineAll>
+              > = {}
+              for (const [modelName, ModelClass] of Object.entries(
+                event.create,
+              )) {
+                const service = spawn(itemMachineAll, {
+                  systemId: modelName,
+                  input: {
+                    modelName,
+                    ModelClass,
+                    modelSchema: (ModelClass as ModelClassType)!.schema,
+                    items: [],
+                  },
+                })
+                allItemsServices[`${modelName}Service`] = service
+              }
+
+              for (const [modelName, snapshot] of Object.entries(
+                event.restore,
+              )) {
+                const service = createActor(itemMachineAll, {
+                  snapshot,
+                })
+                service.start()
+                allItemsServices[`${modelName}Service`] = service
+              }
+              return allItemsServices
+            }),
+            raise({ type: 'allItemsServicesCreated' }),
+          ],
+        },
+      },
+      invoke: {
+        src: 'initialize',
+        input: ({ event, context }) => ({ event, context }),
+        meta: {
+          displayText: 'Initializing Seed SDK',
+          percentComplete: 10,
+        },
+        tags: ['loading'],
+      },
+    },
+    [ADDING_MODELS_TO_DB]: {
+      on: {
+        [GLOBAL_ADDING_MODELS_TO_DB_SUCCESS]: {
+          target: INITIALIZED,
+          actions: assign({
+            addedModelRecordsToDb: true,
+          }),
+        },
+      },
+      invoke: {
+        src: 'addModelsToDb',
+        input: ({ context }) => ({ context }),
+        meta: {
+          displayText: 'Adding models to database',
+        },
+        tags: ['loading'],
+      },
+    },
+    [INITIALIZED]: {
+      type: 'parallel',
+      on: {
+        publishItemRequest: `.${PUBLISHING_ITEM}`,
+      },
+      meta: {
+        displayText: 'Global service ready',
+        percentComplete: 40,
+      },
+      tags: ['loading'],
+      states: {
+        [PUBLISHING_ITEM]: {
+          entry: [
+            assign({
+              publishItemService: ({ spawn, event }) =>
+                spawn(publishMachine, {
+                  id: 'publishService',
+                  input: {
+                    modelName: event.modelName,
+                    localId: event.seedLocalId,
+                  },
+                }),
+            }),
+          ],
+          meta: {
+            displayText: 'Publishing item',
+          },
+          tags: ['publishing'],
+        },
+      },
+    },
+  },
+  // on: {
+  //   '*': {
+  //     actions: emit(({ event }) => {
+  //       return event
+  //     }),
+  //   },
+  // },
+})
+
+const globalService = createActor(globalMachine, {
+  input: {},
+  // inspect,
+  inspect: (inspEvent) => {
+    eventEmitter.emit('inspect.globalService', inspEvent)
+    // console.log('[sdk] [service/index] inspEvent', inspEvent)
+    // eventEmitter.emit('globalService', inspEvent)
+    // let eventType: string = inspEvent.type
+    // if (inspEvent.event && inspEvent.event.type) {
+    //   eventType = inspEvent.event.type
+    // }
+    //
+    // if (typeof eventType === 'object') {
+    //   eventType = JSON.stringify(eventType)
+    // }
+    //
+    // let srcId = inspEvent.actorRef.id
+    //
+    // if (!srcId.includes('seedSdk')) {
+    //   srcId = inspEvent.actorRef.logic.config.id
+    // }
+    //
+    // if (inspEvent.type === '@xstate.snapshot') {
+    //   if (
+    //     inspEvent.event.type === CHILD_SNAPSHOT &&
+    //     inspEvent.snapshot &&
+    //     inspEvent.snapshot.machine.id === MachineIds.GLOBAL
+    //   ) {
+    //     return
+    //   }
+    //   if (inspEvent.snapshot && inspEvent.snapshot.value) {
+    //     if (typeof window !== 'undefined') {
+    //       eventEmitter.emit('globalService', {
+    //         type: eventType,
+    //         src: srcId,
+    //         snapshot: inspEvent.snapshot,
+    //       })
+    //     }
+    //   }
+    // } else {
+    //   if (typeof window !== 'undefined') {
+    //     let snapshot
+    //
+    //     try {
+    //       snapshot = inspEvent.actorRef.getSnapshot()
+    //     } catch (e) {
+    //       // This fails if the actor hasn't initialized yet, but that's OK I think
+    //       // console.log('[sdk] [service/index] ERROR', e)
+    //     }
+    //
+    //     eventEmitter.emit('globalService', {
+    //       type: eventType,
+    //       src: srcId,
+    //       snapshot,
+    //     })
+    //   }
+    // }
+  },
+})
+
+globalService.start()
+
+const getGlobalService = (): ActorRefFrom<typeof globalMachine> => globalService
+
+export { globalMachine, getGlobalService, globalService }

package/dist/src/gql.ts

@@ -0,0 +1,113 @@
+/* eslint-disable */
+import * as types from './graphql';
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+
+/**
+ * Map of all GraphQL operations in the project.
+ *
+ * This map has several performance disadvantages:
+ * 1. It is not tree-shakeable, so it will include all operations in the project.
+ * 2. It is not minifiable, so the string of a GraphQL query will be multiple times inside the bundle.
+ * 3. It does not support dead code elimination, so it will add unused operations.
+ *
+ * Therefore it is highly recommended to use the babel or swc plugin for production.
+ * Learn more about it here: https://the-guild.dev/graphql/codegen/plugins/presets/preset-client#reducing-bundle-size
+ */
+const documents = {
+    "\n  query GetTransactionTags($transactionId: ID!) {\n    tags: transaction(id: $transactionId) {\n      id\n      tags {\n        name\n        value\n      }\n    }\n  }\n": types.GetTransactionTagsDocument,
+    "\n  fragment attestationFields on Attestation {\n    id\n    decodedDataJson\n    attester\n    schema {\n      schemaNames {\n        name\n      }\n    }\n    refUID\n    revoked\n    schemaId\n    txid\n    timeCreated\n    time\n    isOffchain\n  }\n": types.AttestationFieldsFragmentDoc,
+    "\n  fragment schemaFields on Schema {\n    id\n    resolver\n    revocable\n    schema\n    index\n    schemaNames {\n      name\n    }\n    time\n    txid\n    creator\n  }\n": types.SchemaFieldsFragmentDoc,
+    "\n  query GetSchemas($where: SchemaWhereInput!) {\n    schemas: schemata(where: $where) {\n      id\n      schema\n      schemaNames {\n        name\n      }\n    }\n  }\n": types.GetSchemasDocument,
+    "\n  query GetSeeds($where: AttestationWhereInput!) {\n    itemSeeds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n      decodedDataJson\n      attester\n      schema {\n        schemaNames {\n          name\n        }\n      }\n      refUID\n      revoked\n      schemaId\n      timeCreated\n      isOffchain\n    }\n  }\n": types.GetSeedsDocument,
+    "\n  query GetSeedIds($where: AttestationWhereInput!) {\n    itemSeedIds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n    }\n  }\n": types.GetSeedIdsDocument,
+    "\n  query GetStorageTransactionId($where: AttestationWhereInput!) {\n    storageTransactionId: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      id\n      decodedDataJson\n    }\n  }\n": types.GetStorageTransactionIdDocument,
+    "\n  query GetVersions($where: AttestationWhereInput!) {\n    itemVersions: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n": types.GetVersionsDocument,
+    "\n  query GetProperties($where: AttestationWhereInput!) {\n    itemProperties: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n": types.GetPropertiesDocument,
+    "\n  query GetAllPropertiesForAllVersions($where: AttestationWhereInput!) {\n    allProperties: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n": types.GetAllPropertiesForAllVersionsDocument,
+    "\n  query GetFilesMetadata($where: AttestationWhereInput!) {\n    filesMetadata: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n": types.GetFilesMetadataDocument,
+    "\n  query GetArweaveTransactions(\n    $owners: [String!]\n    $first: Int\n    $after: String\n  ) {\n    transactions(owners: $owners, first: $first, after: $after) {\n      edges {\n        cursor\n        node {\n          id\n          anchor\n          signature\n          block {\n            id\n            height\n          }\n          data {\n            size\n            type\n          }\n          tags {\n            name\n            value\n          }\n        }\n      }\n      pageInfo {\n        hasNextPage\n      }\n    }\n  }\n": types.GetArweaveTransactionsDocument,
+    "\n  query GetImageSeeds($where: AttestationWhereInput!) {\n    imageSeeds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n      decodedDataJson\n      attester\n      schema {\n        schemaNames {\n          name\n        }\n      }\n      refUID\n      revoked\n      schemaId\n      txid\n      timeCreated\n      time\n      isOffchain\n    }\n  }\n": types.GetImageSeedsDocument,
+    "\n  query GetImageVersions($where: AttestationWhereInput!) {\n    imageVersions: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n": types.GetImageVersionsDocument,
+    "\n  query GetSchemaUids($where: SchemaWhereInput!) {\n    schemaUids: schemata(where: $where) {\n      id\n      schema\n      schemaNames {\n        name\n      }\n    }\n  }\n": types.GetSchemaUidsDocument,
+};
+
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ *
+ *
+ * @example
+ * ```ts
+ * const query = graphql(`query GetUser($id: ID!) { user(id: $id) { name } }`);
+ * ```
+ *
+ * The query argument is unknown!
+ * Please regenerate the types.
+ */
+export function graphql(source: string): unknown;
+
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetTransactionTags($transactionId: ID!) {\n    tags: transaction(id: $transactionId) {\n      id\n      tags {\n        name\n        value\n      }\n    }\n  }\n"): (typeof documents)["\n  query GetTransactionTags($transactionId: ID!) {\n    tags: transaction(id: $transactionId) {\n      id\n      tags {\n        name\n        value\n      }\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  fragment attestationFields on Attestation {\n    id\n    decodedDataJson\n    attester\n    schema {\n      schemaNames {\n        name\n      }\n    }\n    refUID\n    revoked\n    schemaId\n    txid\n    timeCreated\n    time\n    isOffchain\n  }\n"): (typeof documents)["\n  fragment attestationFields on Attestation {\n    id\n    decodedDataJson\n    attester\n    schema {\n      schemaNames {\n        name\n      }\n    }\n    refUID\n    revoked\n    schemaId\n    txid\n    timeCreated\n    time\n    isOffchain\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  fragment schemaFields on Schema {\n    id\n    resolver\n    revocable\n    schema\n    index\n    schemaNames {\n      name\n    }\n    time\n    txid\n    creator\n  }\n"): (typeof documents)["\n  fragment schemaFields on Schema {\n    id\n    resolver\n    revocable\n    schema\n    index\n    schemaNames {\n      name\n    }\n    time\n    txid\n    creator\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetSchemas($where: SchemaWhereInput!) {\n    schemas: schemata(where: $where) {\n      id\n      schema\n      schemaNames {\n        name\n      }\n    }\n  }\n"): (typeof documents)["\n  query GetSchemas($where: SchemaWhereInput!) {\n    schemas: schemata(where: $where) {\n      id\n      schema\n      schemaNames {\n        name\n      }\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetSeeds($where: AttestationWhereInput!) {\n    itemSeeds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n      decodedDataJson\n      attester\n      schema {\n        schemaNames {\n          name\n        }\n      }\n      refUID\n      revoked\n      schemaId\n      timeCreated\n      isOffchain\n    }\n  }\n"): (typeof documents)["\n  query GetSeeds($where: AttestationWhereInput!) {\n    itemSeeds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n      decodedDataJson\n      attester\n      schema {\n        schemaNames {\n          name\n        }\n      }\n      refUID\n      revoked\n      schemaId\n      timeCreated\n      isOffchain\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetSeedIds($where: AttestationWhereInput!) {\n    itemSeedIds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n    }\n  }\n"): (typeof documents)["\n  query GetSeedIds($where: AttestationWhereInput!) {\n    itemSeedIds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetStorageTransactionId($where: AttestationWhereInput!) {\n    storageTransactionId: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      id\n      decodedDataJson\n    }\n  }\n"): (typeof documents)["\n  query GetStorageTransactionId($where: AttestationWhereInput!) {\n    storageTransactionId: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      id\n      decodedDataJson\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetVersions($where: AttestationWhereInput!) {\n    itemVersions: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"): (typeof documents)["\n  query GetVersions($where: AttestationWhereInput!) {\n    itemVersions: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetProperties($where: AttestationWhereInput!) {\n    itemProperties: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"): (typeof documents)["\n  query GetProperties($where: AttestationWhereInput!) {\n    itemProperties: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetAllPropertiesForAllVersions($where: AttestationWhereInput!) {\n    allProperties: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"): (typeof documents)["\n  query GetAllPropertiesForAllVersions($where: AttestationWhereInput!) {\n    allProperties: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetFilesMetadata($where: AttestationWhereInput!) {\n    filesMetadata: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"): (typeof documents)["\n  query GetFilesMetadata($where: AttestationWhereInput!) {\n    filesMetadata: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetArweaveTransactions(\n    $owners: [String!]\n    $first: Int\n    $after: String\n  ) {\n    transactions(owners: $owners, first: $first, after: $after) {\n      edges {\n        cursor\n        node {\n          id\n          anchor\n          signature\n          block {\n            id\n            height\n          }\n          data {\n            size\n            type\n          }\n          tags {\n            name\n            value\n          }\n        }\n      }\n      pageInfo {\n        hasNextPage\n      }\n    }\n  }\n"): (typeof documents)["\n  query GetArweaveTransactions(\n    $owners: [String!]\n    $first: Int\n    $after: String\n  ) {\n    transactions(owners: $owners, first: $first, after: $after) {\n      edges {\n        cursor\n        node {\n          id\n          anchor\n          signature\n          block {\n            id\n            height\n          }\n          data {\n            size\n            type\n          }\n          tags {\n            name\n            value\n          }\n        }\n      }\n      pageInfo {\n        hasNextPage\n      }\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetImageSeeds($where: AttestationWhereInput!) {\n    imageSeeds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n      decodedDataJson\n      attester\n      schema {\n        schemaNames {\n          name\n        }\n      }\n      refUID\n      revoked\n      schemaId\n      txid\n      timeCreated\n      time\n      isOffchain\n    }\n  }\n"): (typeof documents)["\n  query GetImageSeeds($where: AttestationWhereInput!) {\n    imageSeeds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n      decodedDataJson\n      attester\n      schema {\n        schemaNames {\n          name\n        }\n      }\n      refUID\n      revoked\n      schemaId\n      txid\n      timeCreated\n      time\n      isOffchain\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetImageVersions($where: AttestationWhereInput!) {\n    imageVersions: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"): (typeof documents)["\n  query GetImageVersions($where: AttestationWhereInput!) {\n    imageVersions: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      ...attestationFields\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query GetSchemaUids($where: SchemaWhereInput!) {\n    schemaUids: schemata(where: $where) {\n      id\n      schema\n      schemaNames {\n        name\n      }\n    }\n  }\n"): (typeof documents)["\n  query GetSchemaUids($where: SchemaWhereInput!) {\n    schemaUids: schemata(where: $where) {\n      id\n      schema\n      schemaNames {\n        name\n      }\n    }\n  }\n"];
+
+export function graphql(source: string) {
+  return (documents as any)[source] ?? {};
+}
+
+export type DocumentType<TDocumentNode extends DocumentNode<any, any>> = TDocumentNode extends DocumentNode<  infer TType,  any>  ? TType  : never;