/**
 * This code was GENERATED using the solita package.
 * Please DO NOT EDIT THIS FILE, instead rerun solita to update it or write a wrapper to add functionality.
 *
 * See: https://github.com/metaplex-foundation/solita
 */

type ErrorWithCode = Error & { code: number }
type MaybeErrorWithCode = ErrorWithCode | null | undefined

const createErrorFromCodeLookup: Map<number, () => ErrorWithCode> = new Map()
const createErrorFromNameLookup: Map<string, () => ErrorWithCode> = new Map()

/**
 * InvalidAccountType: 'Invalid account type'
 *
 * @category Errors
 * @category generated
 */
export class InvalidAccountTypeError extends Error {
  readonly code: number = 0x0
  readonly name: string = 'InvalidAccountType'
  constructor() {
    super('Invalid account type')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidAccountTypeError)
    }
  }
}

createErrorFromCodeLookup.set(0x0, () => new InvalidAccountTypeError())
createErrorFromNameLookup.set(
  'InvalidAccountType',
  () => new InvalidAccountTypeError()
)

/**
 * DataTypeMismatch: 'Data type mismatch'
 *
 * @category Errors
 * @category generated
 */
export class DataTypeMismatchError extends Error {
  readonly code: number = 0x1
  readonly name: string = 'DataTypeMismatch'
  constructor() {
    super('Data type mismatch')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, DataTypeMismatchError)
    }
  }
}

createErrorFromCodeLookup.set(0x1, () => new DataTypeMismatchError())
createErrorFromNameLookup.set(
  'DataTypeMismatch',
  () => new DataTypeMismatchError()
)

/**
 * InvalidMint: 'Invalid mint'
 *
 * @category Errors
 * @category generated
 */
export class InvalidMintError extends Error {
  readonly code: number = 0x2
  readonly name: string = 'InvalidMint'
  constructor() {
    super('Invalid mint')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidMintError)
    }
  }
}

createErrorFromCodeLookup.set(0x2, () => new InvalidMintError())
createErrorFromNameLookup.set('InvalidMint', () => new InvalidMintError())

/**
 * InvalidAmount: 'Invalid amount'
 *
 * @category Errors
 * @category generated
 */
export class InvalidAmountError extends Error {
  readonly code: number = 0x3
  readonly name: string = 'InvalidAmount'
  constructor() {
    super('Invalid amount')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidAmountError)
    }
  }
}

createErrorFromCodeLookup.set(0x3, () => new InvalidAmountError())
createErrorFromNameLookup.set('InvalidAmount', () => new InvalidAmountError())

/**
 * InvalidTokenAccount: 'Invalid token account'
 *
 * @category Errors
 * @category generated
 */
export class InvalidTokenAccountError extends Error {
  readonly code: number = 0x4
  readonly name: string = 'InvalidTokenAccount'
  constructor() {
    super('Invalid token account')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidTokenAccountError)
    }
  }
}

createErrorFromCodeLookup.set(0x4, () => new InvalidTokenAccountError())
createErrorFromNameLookup.set(
  'InvalidTokenAccount',
  () => new InvalidTokenAccountError()
)

/**
 * InvalidCollector: 'Invalid collector address'
 *
 * @category Errors
 * @category generated
 */
export class InvalidCollectorError extends Error {
  readonly code: number = 0x5
  readonly name: string = 'InvalidCollector'
  constructor() {
    super('Invalid collector address')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidCollectorError)
    }
  }
}

createErrorFromCodeLookup.set(0x5, () => new InvalidCollectorError())
createErrorFromNameLookup.set(
  'InvalidCollector',
  () => new InvalidCollectorError()
)

/**
 * InvalidRulesetCollector: 'Invalid ruleset collector address'
 *
 * @category Errors
 * @category generated
 */
export class InvalidRulesetCollectorError extends Error {
  readonly code: number = 0x6
  readonly name: string = 'InvalidRulesetCollector'
  constructor() {
    super('Invalid ruleset collector address')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidRulesetCollectorError)
    }
  }
}

createErrorFromCodeLookup.set(0x6, () => new InvalidRulesetCollectorError())
createErrorFromNameLookup.set(
  'InvalidRulesetCollector',
  () => new InvalidRulesetCollectorError()
)

/**
 * InvalidAuthority: 'Invalid authority address'
 *
 * @category Errors
 * @category generated
 */
export class InvalidAuthorityError extends Error {
  readonly code: number = 0x7
  readonly name: string = 'InvalidAuthority'
  constructor() {
    super('Invalid authority address')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidAuthorityError)
    }
  }
}

createErrorFromCodeLookup.set(0x7, () => new InvalidAuthorityError())
createErrorFromNameLookup.set(
  'InvalidAuthority',
  () => new InvalidAuthorityError()
)

/**
 * InvalidMintManager: 'Invalid mint manager'
 *
 * @category Errors
 * @category generated
 */
export class InvalidMintManagerError extends Error {
  readonly code: number = 0x8
  readonly name: string = 'InvalidMintManager'
  constructor() {
    super('Invalid mint manager')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidMintManagerError)
    }
  }
}

createErrorFromCodeLookup.set(0x8, () => new InvalidMintManagerError())
createErrorFromNameLookup.set(
  'InvalidMintManager',
  () => new InvalidMintManagerError()
)

/**
 * InvlaidHolderTokenAccount: 'Invalid holder token account'
 *
 * @category Errors
 * @category generated
 */
export class InvlaidHolderTokenAccountError extends Error {
  readonly code: number = 0x9
  readonly name: string = 'InvlaidHolderTokenAccount'
  constructor() {
    super('Invalid holder token account')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvlaidHolderTokenAccountError)
    }
  }
}

createErrorFromCodeLookup.set(0x9, () => new InvlaidHolderTokenAccountError())
createErrorFromNameLookup.set(
  'InvlaidHolderTokenAccount',
  () => new InvlaidHolderTokenAccountError()
)

/**
 * InvalidTargetTokenAccount: 'Invalid target token account'
 *
 * @category Errors
 * @category generated
 */
export class InvalidTargetTokenAccountError extends Error {
  readonly code: number = 0xa
  readonly name: string = 'InvalidTargetTokenAccount'
  constructor() {
    super('Invalid target token account')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidTargetTokenAccountError)
    }
  }
}

createErrorFromCodeLookup.set(0xa, () => new InvalidTargetTokenAccountError())
createErrorFromNameLookup.set(
  'InvalidTargetTokenAccount',
  () => new InvalidTargetTokenAccountError()
)

/**
 * InvalidCloseTokenAccount: 'Invalid token account to close'
 *
 * @category Errors
 * @category generated
 */
export class InvalidCloseTokenAccountError extends Error {
  readonly code: number = 0xb
  readonly name: string = 'InvalidCloseTokenAccount'
  constructor() {
    super('Invalid token account to close')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidCloseTokenAccountError)
    }
  }
}

createErrorFromCodeLookup.set(0xb, () => new InvalidCloseTokenAccountError())
createErrorFromNameLookup.set(
  'InvalidCloseTokenAccount',
  () => new InvalidCloseTokenAccountError()
)

/**
 * InvalidHolderTokenAccount: 'Invalid holder token account'
 *
 * @category Errors
 * @category generated
 */
export class InvalidHolderTokenAccountError extends Error {
  readonly code: number = 0xc
  readonly name: string = 'InvalidHolderTokenAccount'
  constructor() {
    super('Invalid holder token account')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidHolderTokenAccountError)
    }
  }
}

createErrorFromCodeLookup.set(0xc, () => new InvalidHolderTokenAccountError())
createErrorFromNameLookup.set(
  'InvalidHolderTokenAccount',
  () => new InvalidHolderTokenAccountError()
)

/**
 * InvalidRuleset: 'Invalid ruleset'
 *
 * @category Errors
 * @category generated
 */
export class InvalidRulesetError extends Error {
  readonly code: number = 0xd
  readonly name: string = 'InvalidRuleset'
  constructor() {
    super('Invalid ruleset')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidRulesetError)
    }
  }
}

createErrorFromCodeLookup.set(0xd, () => new InvalidRulesetError())
createErrorFromNameLookup.set('InvalidRuleset', () => new InvalidRulesetError())

/**
 * InvalidPreTransferInstruction: 'Invalid pre transfer instruction'
 *
 * @category Errors
 * @category generated
 */
export class InvalidPreTransferInstructionError extends Error {
  readonly code: number = 0xe
  readonly name: string = 'InvalidPreTransferInstruction'
  constructor() {
    super('Invalid pre transfer instruction')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidPreTransferInstructionError)
    }
  }
}

createErrorFromCodeLookup.set(
  0xe,
  () => new InvalidPreTransferInstructionError()
)
createErrorFromNameLookup.set(
  'InvalidPreTransferInstruction',
  () => new InvalidPreTransferInstructionError()
)

/**
 * InvalidPostTransferInstruction: 'Invalid post transfer instruction'
 *
 * @category Errors
 * @category generated
 */
export class InvalidPostTransferInstructionError extends Error {
  readonly code: number = 0xf
  readonly name: string = 'InvalidPostTransferInstruction'
  constructor() {
    super('Invalid post transfer instruction')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidPostTransferInstructionError)
    }
  }
}

createErrorFromCodeLookup.set(
  0xf,
  () => new InvalidPostTransferInstructionError()
)
createErrorFromNameLookup.set(
  'InvalidPostTransferInstruction',
  () => new InvalidPostTransferInstructionError()
)

/**
 * ProgramDisallowed: 'Disallowed program included in transfer'
 *
 * @category Errors
 * @category generated
 */
export class ProgramDisallowedError extends Error {
  readonly code: number = 0x10
  readonly name: string = 'ProgramDisallowed'
  constructor() {
    super('Disallowed program included in transfer')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ProgramDisallowedError)
    }
  }
}

createErrorFromCodeLookup.set(0x10, () => new ProgramDisallowedError())
createErrorFromNameLookup.set(
  'ProgramDisallowed',
  () => new ProgramDisallowedError()
)

/**
 * ProgramNotAllowed: 'Program not allowed in allowed programs to transfer'
 *
 * @category Errors
 * @category generated
 */
export class ProgramNotAllowedError extends Error {
  readonly code: number = 0x11
  readonly name: string = 'ProgramNotAllowed'
  constructor() {
    super('Program not allowed in allowed programs to transfer')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ProgramNotAllowedError)
    }
  }
}

createErrorFromCodeLookup.set(0x11, () => new ProgramNotAllowedError())
createErrorFromNameLookup.set(
  'ProgramNotAllowed',
  () => new ProgramNotAllowedError()
)

/**
 * UnknownAccount: 'Unknown account found in instruction'
 *
 * @category Errors
 * @category generated
 */
export class UnknownAccountError extends Error {
  readonly code: number = 0x12
  readonly name: string = 'UnknownAccount'
  constructor() {
    super('Unknown account found in instruction')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, UnknownAccountError)
    }
  }
}

createErrorFromCodeLookup.set(0x12, () => new UnknownAccountError())
createErrorFromNameLookup.set('UnknownAccount', () => new UnknownAccountError())

/**
 * AccountNotFound: 'Account not found in instruction'
 *
 * @category Errors
 * @category generated
 */
export class AccountNotFoundError extends Error {
  readonly code: number = 0x13
  readonly name: string = 'AccountNotFound'
  constructor() {
    super('Account not found in instruction')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AccountNotFoundError)
    }
  }
}

createErrorFromCodeLookup.set(0x13, () => new AccountNotFoundError())
createErrorFromNameLookup.set(
  'AccountNotFound',
  () => new AccountNotFoundError()
)

/**
 * TokenAlreadyInUse: 'Token already in use'
 *
 * @category Errors
 * @category generated
 */
export class TokenAlreadyInUseError extends Error {
  readonly code: number = 0x14
  readonly name: string = 'TokenAlreadyInUse'
  constructor() {
    super('Token already in use')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TokenAlreadyInUseError)
    }
  }
}

createErrorFromCodeLookup.set(0x14, () => new TokenAlreadyInUseError())
createErrorFromNameLookup.set(
  'TokenAlreadyInUse',
  () => new TokenAlreadyInUseError()
)

/**
 * InvalidTokenUser: 'Invalid token user'
 *
 * @category Errors
 * @category generated
 */
export class InvalidTokenUserError extends Error {
  readonly code: number = 0x15
  readonly name: string = 'InvalidTokenUser'
  constructor() {
    super('Invalid token user')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidTokenUserError)
    }
  }
}

createErrorFromCodeLookup.set(0x15, () => new InvalidTokenUserError())
createErrorFromNameLookup.set(
  'InvalidTokenUser',
  () => new InvalidTokenUserError()
)

/**
 * TokenCurentlyInUse: 'Token currently in use'
 *
 * @category Errors
 * @category generated
 */
export class TokenCurentlyInUseError extends Error {
  readonly code: number = 0x16
  readonly name: string = 'TokenCurentlyInUse'
  constructor() {
    super('Token currently in use')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TokenCurentlyInUseError)
    }
  }
}

createErrorFromCodeLookup.set(0x16, () => new TokenCurentlyInUseError())
createErrorFromNameLookup.set(
  'TokenCurentlyInUse',
  () => new TokenCurentlyInUseError()
)

/**
 * InvalidRulesetAuthority: 'Invalid ruleset authority'
 *
 * @category Errors
 * @category generated
 */
export class InvalidRulesetAuthorityError extends Error {
  readonly code: number = 0x17
  readonly name: string = 'InvalidRulesetAuthority'
  constructor() {
    super('Invalid ruleset authority')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidRulesetAuthorityError)
    }
  }
}

createErrorFromCodeLookup.set(0x17, () => new InvalidRulesetAuthorityError())
createErrorFromNameLookup.set(
  'InvalidRulesetAuthority',
  () => new InvalidRulesetAuthorityError()
)

/**
 * Attempts to resolve a custom program error from the provided error code.
 * @category Errors
 * @category generated
 */
export function errorFromCode(code: number): MaybeErrorWithCode {
  const createError = createErrorFromCodeLookup.get(code)
  return createError != null ? createError() : null
}

/**
 * Attempts to resolve a custom program error from the provided error name, i.e. 'Unauthorized'.
 * @category Errors
 * @category generated
 */
export function errorFromName(name: string): MaybeErrorWithCode {
  const createError = createErrorFromNameLookup.get(name)
  return createError != null ? createError() : null
}