api-schema.graphql

# ------------------------------------------------------
# THIS FILE WAS AUTOMATICALLY GENERATED (DO NOT MODIFY)
# ------------------------------------------------------

type App {
  createdAt: DateTime!
  defaultEnvUrl: String
  envs: [AppEnv!]
  id: String!
  index: Int!
  name: String
  settingsUrl: String
  updatedAt: DateTime!
  users: [AppUser!]
}

input AppCreateInput {
  index: Int!
  name: String!
  skipWalletCreation: Boolean
}

type AppEnv {
  app: App
  cluster: Cluster
  createdAt: DateTime!
  id: String!
  key: String
  mints: [AppMint!]
  name: String
  updatedAt: DateTime!
  wallets: [Wallet!]
  webhookAcceptIncoming: Boolean
  webhookEventEnabled: Boolean
  webhookEventUrl: String
  webhookSecret: String
  webhookVerifyEnabled: Boolean
  webhookVerifyUrl: String
}

input AppEnvUpdateInput {
  webhookAcceptIncoming: Boolean
  webhookEventEnabled: Boolean
  webhookEventUrl: String
  webhookSecret: String
  webhookVerifyEnabled: Boolean
  webhookVerifyUrl: String
}

type AppMint {
  addMemo: Boolean
  createdAt: DateTime!
  id: String!
  mint: Mint
  order: Int
  updatedAt: DateTime!
  wallet: Wallet
}

input AppMintUpdateInput {
  addMemo: Boolean
}

type AppTransaction {
  amount: String
  createdAt: DateTime
  destination: String
  errors: [AppTransactionError!]
  explorerUrl: String
  feePayer: String
  id: String
  mint: String
  processingDuration: Int
  referenceId: String
  referenceType: String
  signature: String
  solanaCommitted: DateTime
  solanaCommittedDuration: Int
  solanaFinalized: DateTime
  solanaFinalizedDuration: Int
  solanaStart: DateTime
  solanaTransaction: JSON
  source: String
  status: AppTransactionStatus!
  totalDuration: Int
  updatedAt: DateTime
  webhookEventDuration: Int
  webhookEventEnd: DateTime
  webhookEventIncoming: AppWebhook
  webhookEventOutgoing: AppWebhook
  webhookEventStart: DateTime
  webhookVerifyDuration: Int
  webhookVerifyEnd: DateTime
  webhookVerifyIncoming: AppWebhook
  webhookVerifyOutgoing: AppWebhook
  webhookVerifyStart: DateTime
}

type AppTransactionCounter {
  limit: Float
  page: Float
  pageCount: Float
  total: Float
}

type AppTransactionError {
  id: String
  instruction: Int
  logs: [String!]
  message: String
  type: AppTransactionErrorType!
}

enum AppTransactionErrorType {
  BadNonce
  InvalidAccount
  SomeError
  Unknown
  WebhookFailed
}

input AppTransactionListInput {
  destination: String
  limit: Float
  page: Float
  referenceId: String
  referenceType: String
  signature: String
  source: String
  status: [AppTransactionStatus!]
}

enum AppTransactionStatus {
  Committed
  Confirmed
  Failed
  Finalized
  Processing
}

input AppUpdateInput {
  name: String
}

type AppUser {
  app: App
  createdAt: DateTime!
  id: String!
  role: AppUserRole!
  updatedAt: DateTime!
  user: User
}

input AppUserAddInput {
  role: AppUserRole!
  userId: String!
}

input AppUserRemoveInput {
  userId: String!
}

enum AppUserRole {
  Member
  Owner
}

input AppUserUpdateRoleInput {
  role: AppUserRole!
  userId: String!
}

type AppWebhook {
  createdAt: DateTime!
  direction: AppWebhookDirection!
  headers: JSON
  id: String!
  payload: JSON
  responseError: String
  responsePayload: JSON
  responseStatus: Int
  type: AppWebhookType!
  updatedAt: DateTime!
}

enum AppWebhookDirection {
  Incoming
  Outgoing
}

enum AppWebhookType {
  Event
  Verify
}

type AuthToken {
  token: String!
  user: User!
}

"""
The `BigInt` scalar type represents non-fractional signed whole numeric values.
"""
scalar BigInt

type Cluster {
  createdAt: DateTime
  enableStats: Boolean
  endpointPrivate: String
  endpointPublic: String
  explorer: String
  id: String
  mints: [Mint!]
  name: String
  status: ClusterStatus
  type: ClusterType
  updatedAt: DateTime
}

input ClusterCreateInput {
  endpointPrivate: String!
  endpointPublic: String!
  explorer: String
  name: String!
  type: ClusterType!
}

type ClusterStat {
  createdAt: DateTime!
  id: String!
  numSlots: Float
  numTransactions: Float!
  samplePeriodSecs: Float!
  slot: Float!
  updatedAt: DateTime!
}

enum ClusterStatus {
  Active
  Inactive
}

type ClusterToken {
  address: String
  decimals: Int
  extensions: ClusterTokenExtensions
  logoURI: String
  name: String
  symbol: String
  tags: [String!]
}

type ClusterTokenExtensions {
  address: String
  assetContract: String
  bridgeContract: String
  coinGeckoId: String
  description: String
  discord: String
  explorer: String
  github: String
  imageUrl: String
  medium: String
  serumV3Usdc: String
  serumV3Usdt: String
  tgann: String
  tggroup: String
  twitter: String
  website: String
}

input ClusterTokenInput {
  address: String
  name: String
  symbol: String
  type: ClusterType!
}

enum ClusterType {
  Custom
  SolanaDevnet
  SolanaMainnet
  SolanaTestnet
}

input ClusterUpdateInput {
  enableStats: Boolean
  endpointPrivate: String
  endpointPublic: String
  explorer: String
  name: String
  status: ClusterStatus
}

"""
A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format.
"""
scalar DateTime

"""
The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).
"""
scalar JSON

input LoginInput {
  password: String!
  username: String!
}

type Mint {
  addMemo: Boolean
  address: String
  airdropAmount: Int
  airdropMax: Int
  airdropPublicKey: String
  coinGeckoId: String
  createdAt: DateTime
  decimals: Int
  default: Boolean
  enabled: Boolean
  id: String
  logoUrl: String
  name: String
  order: Int
  symbol: String
  type: MintType
  updatedAt: DateTime
}

input MintAddInput {
  address: String!
  clusterId: String!
  name: String!
  symbol: String!
}

enum MintType {
  SplToken
}

type Mutation {
  adminAddClusterMint(input: MintAddInput!): Cluster
  adminCreateApp(input: AppCreateInput!): App
  adminCreateCluster(input: ClusterCreateInput!): Cluster
  adminCreateUser(input: UserCreateInput!): User
  adminDeleteApp(appId: String!): App
  adminDeleteCluster(clusterId: String!): Cluster
  adminDeleteUser(userId: String!): User
  adminDeleteWallet(walletId: String!): Wallet
  adminUpdateCluster(clusterId: String!, input: ClusterUpdateInput!): Cluster
  adminUpdateUser(input: UserUpdateInput!, userId: String!): User
  login(input: LoginInput!): AuthToken
  logout: Boolean
  userAppEnvMintDisable(appEnvId: String!, appId: String!, mintId: String!): AppEnv
  userAppEnvMintEnable(appEnvId: String!, appId: String!, mintId: String!): AppEnv
  userAppEnvMintSetWallet(appEnvId: String!, appId: String!, mintId: String!, walletId: String!): AppEnv
  userAppEnvWalletAdd(appEnvId: String!, appId: String!, walletId: String!): AppEnv
  userAppEnvWalletRemove(appEnvId: String!, appId: String!, walletId: String!): AppEnv
  userAppUserAdd(appId: String!, input: AppUserAddInput!): App
  userAppUserRemove(appId: String!, input: AppUserRemoveInput!): App
  userAppUserUpdateRole(appId: String!, input: AppUserUpdateRoleInput!): App
  userDeleteWallet(appEnvId: String!, walletId: String!): Wallet
  userGenerateWallet(appEnvId: String!): Wallet
  userImportWallet(appEnvId: String!, secretKey: String!): Wallet
  userUpdateApp(appId: String!, input: AppUpdateInput!): App
  userUpdateAppEnv(appEnvId: String!, appId: String!, input: AppEnvUpdateInput!): AppEnv
  userUpdateAppMint(appId: String!, appMintId: String!, input: AppMintUpdateInput!): AppMint
}

type Query {
  adminApp(appId: String!): App
  adminApps: [App!]
  adminCluster(clusterId: String!): Cluster
  adminClusterTokens(input: ClusterTokenInput!): [ClusterToken!]
  adminClusters: [Cluster!]
  adminUser(userId: String!): User
  adminUsers: [User!]
  adminWallet(walletId: String!): Wallet
  adminWalletBalances(appEnvId: String!, walletId: String!): [WalletBalance!]
  adminWallets: [Wallet!]
  clusterStats(clusterId: String!): [ClusterStat!]
  me: User
  uptime: Float!
  userApp(appId: String!): App
  userAppEnv(appEnvId: String!, appId: String!): AppEnv
  userAppRole(appId: String!): AppUserRole
  userAppTransaction(appEnvId: String!, appId: String!, appTransactionId: String!): AppTransaction
  userAppTransactionCounter(appEnvId: String!, appId: String!, input: AppTransactionListInput): AppTransactionCounter
  userAppTransactions(appEnvId: String!, appId: String!, input: AppTransactionListInput): [AppTransaction!]
  userApps: [App!]
  userWallet(appEnvId: String!, walletId: String!): Wallet
  userWalletAirdrop(amount: Float!, appEnvId: String!, walletId: String!): WalletAirdropResponse
  userWalletBalance(appEnvId: String!, walletId: String!): WalletBalance
  userWalletBalances(appEnvId: String!, walletId: String!): [WalletBalance!]
  userWallets(appEnvId: String!): [Wallet!]
}

type User {
  apps: [AppUser!]
  avatarUrl: String
  createdAt: DateTime!
  email: String
  emails: [UserEmail!]
  id: String!
  name: String
  role: UserRole
  updatedAt: DateTime!
  username: String!
}

input UserCreateInput {
  avatarUrl: String
  email: String!
  name: String
  password: String!
  role: UserRole
  username: String
}

type UserEmail {
  createdAt: DateTime!
  email: String!
  id: String!
  updatedAt: DateTime!
}

enum UserRole {
  Admin
  User
}

input UserUpdateInput {
  avatarUrl: String
  name: String
  role: UserRole
}

type Wallet {
  appEnvs: [AppEnv!]
  appMints: [AppMint!]
  balances: [WalletBalance!]
  createdAt: DateTime
  id: String!
  owner: User
  publicKey: String
  type: WalletType
  updatedAt: DateTime
}

type WalletAirdropResponse {
  signature: String
}

type WalletBalance {
  appEnv: AppEnv
  balance: BigInt
  change: BigInt
  createdAt: DateTime
  id: String
  updatedAt: DateTime
}

enum WalletType {
  Generated
  Imported
  Provisioned
}