api-schema.graphql

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

input AdminAppCreateInput {
  enableWebhooks: Boolean
  index: Int!
  logoUrl: String
  name: String!
  skipWalletCreation: Boolean
}

input AdminAppUpdateInput {
  index: Int
  logoUrl: String
  maxEnvs: Int
  name: String
}

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

input AdminClusterUpdateInput {
  endpointPrivate: String
  endpointPublic: String
  explorer: String
  name: String
  status: ClusterStatus
}

input AdminMintCreateInput {
  address: String!
  clusterId: String!
  coinGeckoId: String
  decimals: Int!
  logoUrl: String
  name: String!
  symbol: String!
}

input AdminQueueLoadInput {
  environment: String!
  index: Int!
  payload: JSON!
  type: QueueType!
}

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

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

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

type AppEnv {
  app: App
  cluster: Cluster
  createdAt: DateTime!
  endpoint: String
  id: String!
  ipsAllowed: [String!]
  ipsBlocked: [String!]
  key: String
  mints: [AppMint!]
  name: String
  solanaTransactionMaxRetries: Int
  solanaTransactionSkipPreflight: Boolean
  uasAllowed: [String!]
  uasBlocked: [String!]
  updatedAt: DateTime!
  wallets: [Wallet!]
  webhookBalanceEnabled: Boolean
  webhookBalanceThreshold: String
  webhookBalanceUrl: String
  webhookDebugging: Boolean
  webhookEventEnabled: Boolean
  webhookEventUrl: String
  webhookSecret: String
  webhookVerifyEnabled: Boolean
  webhookVerifyUrl: String
}

type AppEnvStats {
  transactionCount: AppEnvTransactionCount
}

type AppEnvTransactionCount {
  Committed: Int
  Confirmed: Int
  Failed: Int
  Finalized: Int
  Processing: Int
}

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

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

enum AppUserRole {
  Member
  Owner
}

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

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

enum ClusterStatus {
  Active
  Inactive
}

enum ClusterType {
  Custom
  SolanaDevnet
  SolanaMainnet
  SolanaTestnet
}

"""
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 @specifiedBy(url: "http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf")

type Job {
  attemptsMade: Int
  data: JSON
  failedReason: String
  finishedOn: Int
  id: String
  name: String
  opts: JSON
  processedOn: Int
  returnvalue: JSON
  stacktrace: [String!]
  timestamp: Int
}

enum JobStatus {
  active
  completed
  delayed
  failed
  paused
  waiting
}

type Migration {
  key: String!
  status: MigrationStatus!
  version: String!
}

type MigrationStatus {
  count: Int!
  done: Boolean!
}

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
}

enum MintType {
  SplToken
}

type Mutation {
  adminCreateApp(input: AdminAppCreateInput!): App
  adminCreateCluster(input: AdminClusterCreateInput!): Cluster
  adminCreateUser(input: AdminUserCreateInput!): User
  adminDeleteApp(appId: String!): App
  adminDeleteAppEnv(appEnvId: String!, appId: String!): AppEnv
  adminDeleteCluster(clusterId: String!): Cluster
  adminDeleteMint(mintId: String!): Mint
  adminDeleteUser(userId: String!): User
  adminDeleteWallet(walletId: String!): Wallet
  adminMigrate(key: String!): MigrationStatus
  adminMintCreate(input: AdminMintCreateInput!): Cluster
  adminMintImportWallet(mintId: String!, secret: String!): Mint
  adminQueueClean(status: JobStatus, type: QueueType!): Boolean
  adminQueueDeleteJob(jobId: String!, type: QueueType!): Boolean
  adminQueueLoad(input: AdminQueueLoadInput!): Queue
  adminQueuePause(type: QueueType!): Boolean
  adminQueueResume(type: QueueType!): Boolean
  adminUpdateApp(appId: String!, input: AdminAppUpdateInput!): App
  adminUpdateCluster(clusterId: String!, input: AdminClusterUpdateInput!): Cluster
  adminUpdateUser(input: AdminUserUpdateInput!, userId: String!): User
  login(input: UserLoginInput!): AuthToken
  logout: Boolean
  userAppEnvAddAllowedIp(appEnvId: String!, ip: String!): AppEnv
  userAppEnvAddAllowedUa(appEnvId: String!, ua: String!): AppEnv
  userAppEnvAddBlockedIp(appEnvId: String!, ip: String!): AppEnv
  userAppEnvAddBlockedUa(appEnvId: String!, ua: String!): AppEnv
  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
  userAppEnvPurgeTransactions(appEnvId: String!, status: TransactionStatus): AppEnv
  userAppEnvRemoveAllowedIp(appEnvId: String!, ip: String!): AppEnv
  userAppEnvRemoveAllowedUa(appEnvId: String!, ua: String!): AppEnv
  userAppEnvRemoveBlockedIp(appEnvId: String!, ip: String!): AppEnv
  userAppEnvRemoveBlockedUa(appEnvId: String!, ua: String!): AppEnv
  userAppEnvWalletAdd(appEnvId: String!, appId: String!, walletId: String!): AppEnv
  userAppEnvWalletRemove(appEnvId: String!, appId: String!, walletId: String!): AppEnv
  userAppUserAdd(appId: String!, input: UserAppUserAddInput!): App
  userAppUserRemove(appId: String!, input: UserAppUserRemoveInput!): App
  userAppUserUpdateRole(appId: String!, input: UserAppUserUpdateRoleInput!): App
  userCreateAppEnv(appId: String!, clusterId: String!, input: UserAppEnvCreateInput!): AppEnv
  userDeleteAppEnv(appEnvId: String!, appId: String!): AppEnv
  userDeleteWallet(appEnvId: String!, walletId: String!): Wallet
  userGenerateWallet(appEnvId: String!): Wallet
  userImportWallet(appEnvId: String!, secret: String!): Wallet
  userUpdateApp(appId: String!, input: UserAppUpdateInput!): App
  userUpdateAppEnv(appEnvId: String!, appId: String!, input: UserAppEnvUpdateInput!): AppEnv
  userUpdateAppMint(appId: String!, appMintId: String!, input: UserAppMintUpdateInput!): AppMint
}

type Query {
  adminApp(appId: String!): App
  adminApps: [App!]
  adminCluster(clusterId: String!): Cluster
  adminClusters: [Cluster!]
  adminMigrations: [Migration!]
  adminQueue(type: QueueType!): Queue
  adminQueueJobs(statuses: [JobStatus!]!, type: QueueType!): [Job!]
  adminQueues: [Queue!]
  adminUser(userId: String!): User
  adminUsers: [User!]
  adminWallet(walletId: String!): Wallet
  adminWallets: [Wallet!]
  me: User
  uptime: Float!
  userApp(appId: String!): App
  userAppEnv(appEnvId: String!, appId: String!): AppEnv
  userAppEnvStats(appEnvId: String!): AppEnvStats
  userAppRole(appId: String!): AppUserRole
  userApps: [App!]
  userCluster(clusterId: String!): Cluster
  userClusters: [Cluster!]
  userSearchUsers(input: UserSearchUserInput!): [User!]
  userTransaction(appEnvId: String!, appId: String!, transactionId: String!): Transaction
  userTransactionCounter(appEnvId: String!, appId: String!, input: UserTransactionListInput): TransactionCounter
  userTransactions(appEnvId: String!, appId: String!, input: UserTransactionListInput): [Transaction!]
  userWallet(appEnvId: String!, walletId: String!): Wallet
  userWalletAirdrop(amount: Float!, appEnvId: String!, walletId: String!): WalletAirdropResponse
  userWalletBalance(appEnvId: String!, walletId: String!): String
  userWallets(appEnvId: String!): [Wallet!]
  webConfig: WebConfig!
}

type Queue {
  count: QueueCount
  info: JSON
  isPaused: Boolean
  name: String!
  type: QueueType!
}

type QueueCount {
  active: Int
  completed: Int
  delayed: Int
  failed: Int
  paused: Int
  waiting: Int
}

enum QueueType {
  CloseAccount
}

type Transaction {
  amount: String
  createdAt: DateTime
  decimals: Int
  destination: String
  errors: [TransactionError!]
  explorerUrl: String
  feePayer: String
  id: String
  ip: String
  mint: String
  processingDuration: Int
  reference: String
  signature: String
  solanaCommitted: DateTime
  solanaCommittedDuration: Int
  solanaFinalized: DateTime
  solanaFinalizedDuration: Int
  solanaStart: DateTime
  solanaTransaction: JSON
  source: String
  status: TransactionStatus!
  totalDuration: Int
  tx: String
  ua: String
  updatedAt: DateTime
  webhookEventDuration: Int
  webhookEventEnd: DateTime
  webhookEventIncoming: Webhook
  webhookEventOutgoing: Webhook
  webhookEventStart: DateTime
  webhookVerifyDuration: Int
  webhookVerifyEnd: DateTime
  webhookVerifyIncoming: Webhook
  webhookVerifyOutgoing: Webhook
  webhookVerifyStart: DateTime
}

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

type TransactionError {
  id: String
  instruction: Int
  logs: [String!]
  message: String
  type: TransactionErrorType!
}

enum TransactionErrorType {
  BadNonce
  InvalidAccount
  SomeError
  Timeout
  Unknown
  WebhookFailed
}

enum TransactionStatus {
  Committed
  Confirmed
  Failed
  Finalized
  Processing
}

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

input UserAppEnvCreateInput {
  name: String!
}

input UserAppEnvUpdateInput {
  solanaTransactionMaxRetries: Int
  solanaTransactionSkipPreflight: Boolean
  webhookBalanceEnabled: Boolean
  webhookBalanceThreshold: String
  webhookBalanceUrl: String
  webhookDebugging: Boolean
  webhookEventEnabled: Boolean
  webhookEventUrl: String
  webhookSecret: String
  webhookVerifyEnabled: Boolean
  webhookVerifyUrl: String
}

input UserAppMintUpdateInput {
  addMemo: Boolean
}

input UserAppUpdateInput {
  logoUrl: String
  name: String
}

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

input UserAppUserRemoveInput {
  userId: String!
}

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

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

type UserIdentity {
  createdAt: DateTime!
  externalId: String!
  id: String!
  profile: JSON!
  type: UserIdentityType
  updatedAt: DateTime!
}

enum UserIdentityType {
  Discord
  GitHub
  Google
}

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

enum UserRole {
  Admin
  User
}

input UserSearchUserInput {
  query: String
}

input UserTransactionListInput {
  destination: String
  ip: String
  limit: Float
  page: Float
  reference: String
  signature: String
  source: String
  status: [TransactionStatus!]
  ua: String
}

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

type WalletAirdropResponse {
  signature: String
}

enum WalletType {
  Generated
  Imported
  Provisioned
}

type WebConfig {
  discordEnabled: Boolean!
  githubEnabled: Boolean!
  googleEnabled: Boolean!
  passwordEnabled: Boolean!
}

type Webhook {
  createdAt: DateTime!
  direction: WebhookDirection!
  headers: JSON
  id: String!
  payload: JSON
  responseError: String
  responsePayload: JSON
  responseStatus: Int
  type: WebhookType!
  updatedAt: DateTime!
}

enum WebhookDirection {
  Incoming
  Outgoing
}

enum WebhookType {
  Balance
  Event
  Verify
}