solana-framework/src/nft/mpl-token-metadata/generated/errors/index.ts

solana-framework is solana uni-tools for typescript

/**
 * 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();

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

createErrorFromCodeLookup.set(0x0, () => new InstructionUnpackErrorError());
createErrorFromNameLookup.set('InstructionUnpackError', () => new InstructionUnpackErrorError());

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

createErrorFromCodeLookup.set(0x1, () => new InstructionPackErrorError());
createErrorFromNameLookup.set('InstructionPackError', () => new InstructionPackErrorError());

/**
 * NotRentExempt: 'Lamport balance below rent-exempt threshold'
 *
 * @category Errors
 * @category generated
 */
export class NotRentExemptError extends Error {
  readonly code: number = 0x2;
  readonly name: string = 'NotRentExempt';
  constructor() {
    super('Lamport balance below rent-exempt threshold');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotRentExemptError);
    }
  }
}

createErrorFromCodeLookup.set(0x2, () => new NotRentExemptError());
createErrorFromNameLookup.set('NotRentExempt', () => new NotRentExemptError());

/**
 * AlreadyInitialized: 'Already initialized'
 *
 * @category Errors
 * @category generated
 */
export class AlreadyInitializedError extends Error {
  readonly code: number = 0x3;
  readonly name: string = 'AlreadyInitialized';
  constructor() {
    super('Already initialized');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AlreadyInitializedError);
    }
  }
}

createErrorFromCodeLookup.set(0x3, () => new AlreadyInitializedError());
createErrorFromNameLookup.set('AlreadyInitialized', () => new AlreadyInitializedError());

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

createErrorFromCodeLookup.set(0x4, () => new UninitializedError());
createErrorFromNameLookup.set('Uninitialized', () => new UninitializedError());

/**
 * InvalidMetadataKey: ' Metadata's key must match seed of ['metadata', program id, mint] provided'
 *
 * @category Errors
 * @category generated
 */
export class InvalidMetadataKeyError extends Error {
  readonly code: number = 0x5;
  readonly name: string = 'InvalidMetadataKey';
  constructor() {
    super(" Metadata's key must match seed of ['metadata', program id, mint] provided");
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidMetadataKeyError);
    }
  }
}

createErrorFromCodeLookup.set(0x5, () => new InvalidMetadataKeyError());
createErrorFromNameLookup.set('InvalidMetadataKey', () => new InvalidMetadataKeyError());

/**
 * InvalidEditionKey: 'Edition's key must match seed of ['metadata', program id, name, 'edition'] provided'
 *
 * @category Errors
 * @category generated
 */
export class InvalidEditionKeyError extends Error {
  readonly code: number = 0x6;
  readonly name: string = 'InvalidEditionKey';
  constructor() {
    super("Edition's key must match seed of ['metadata', program id, name, 'edition'] provided");
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidEditionKeyError);
    }
  }
}

createErrorFromCodeLookup.set(0x6, () => new InvalidEditionKeyError());
createErrorFromNameLookup.set('InvalidEditionKey', () => new InvalidEditionKeyError());

/**
 * UpdateAuthorityIncorrect: 'Update Authority given does not match'
 *
 * @category Errors
 * @category generated
 */
export class UpdateAuthorityIncorrectError extends Error {
  readonly code: number = 0x7;
  readonly name: string = 'UpdateAuthorityIncorrect';
  constructor() {
    super('Update Authority given does not match');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, UpdateAuthorityIncorrectError);
    }
  }
}

createErrorFromCodeLookup.set(0x7, () => new UpdateAuthorityIncorrectError());
createErrorFromNameLookup.set(
  'UpdateAuthorityIncorrect',
  () => new UpdateAuthorityIncorrectError(),
);

/**
 * UpdateAuthorityIsNotSigner: 'Update Authority needs to be signer to update metadata'
 *
 * @category Errors
 * @category generated
 */
export class UpdateAuthorityIsNotSignerError extends Error {
  readonly code: number = 0x8;
  readonly name: string = 'UpdateAuthorityIsNotSigner';
  constructor() {
    super('Update Authority needs to be signer to update metadata');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, UpdateAuthorityIsNotSignerError);
    }
  }
}

createErrorFromCodeLookup.set(0x8, () => new UpdateAuthorityIsNotSignerError());
createErrorFromNameLookup.set(
  'UpdateAuthorityIsNotSigner',
  () => new UpdateAuthorityIsNotSignerError(),
);

/**
 * NotMintAuthority: 'You must be the mint authority and signer on this transaction'
 *
 * @category Errors
 * @category generated
 */
export class NotMintAuthorityError extends Error {
  readonly code: number = 0x9;
  readonly name: string = 'NotMintAuthority';
  constructor() {
    super('You must be the mint authority and signer on this transaction');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotMintAuthorityError);
    }
  }
}

createErrorFromCodeLookup.set(0x9, () => new NotMintAuthorityError());
createErrorFromNameLookup.set('NotMintAuthority', () => new NotMintAuthorityError());

/**
 * InvalidMintAuthority: 'Mint authority provided does not match the authority on the mint'
 *
 * @category Errors
 * @category generated
 */
export class InvalidMintAuthorityError extends Error {
  readonly code: number = 0xa;
  readonly name: string = 'InvalidMintAuthority';
  constructor() {
    super('Mint authority provided does not match the authority on the mint');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidMintAuthorityError);
    }
  }
}

createErrorFromCodeLookup.set(0xa, () => new InvalidMintAuthorityError());
createErrorFromNameLookup.set('InvalidMintAuthority', () => new InvalidMintAuthorityError());

/**
 * NameTooLong: 'Name too long'
 *
 * @category Errors
 * @category generated
 */
export class NameTooLongError extends Error {
  readonly code: number = 0xb;
  readonly name: string = 'NameTooLong';
  constructor() {
    super('Name too long');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NameTooLongError);
    }
  }
}

createErrorFromCodeLookup.set(0xb, () => new NameTooLongError());
createErrorFromNameLookup.set('NameTooLong', () => new NameTooLongError());

/**
 * SymbolTooLong: 'Symbol too long'
 *
 * @category Errors
 * @category generated
 */
export class SymbolTooLongError extends Error {
  readonly code: number = 0xc;
  readonly name: string = 'SymbolTooLong';
  constructor() {
    super('Symbol too long');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, SymbolTooLongError);
    }
  }
}

createErrorFromCodeLookup.set(0xc, () => new SymbolTooLongError());
createErrorFromNameLookup.set('SymbolTooLong', () => new SymbolTooLongError());

/**
 * UriTooLong: 'URI too long'
 *
 * @category Errors
 * @category generated
 */
export class UriTooLongError extends Error {
  readonly code: number = 0xd;
  readonly name: string = 'UriTooLong';
  constructor() {
    super('URI too long');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, UriTooLongError);
    }
  }
}

createErrorFromCodeLookup.set(0xd, () => new UriTooLongError());
createErrorFromNameLookup.set('UriTooLong', () => new UriTooLongError());

/**
 * UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner: ''
 *
 * @category Errors
 * @category generated
 */
export class UpdateAuthorityMustBeEqualToMetadataAuthorityAndSignerError extends Error {
  readonly code: number = 0xe;
  readonly name: string = 'UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, UpdateAuthorityMustBeEqualToMetadataAuthorityAndSignerError);
    }
  }
}

createErrorFromCodeLookup.set(
  0xe,
  () => new UpdateAuthorityMustBeEqualToMetadataAuthorityAndSignerError(),
);
createErrorFromNameLookup.set(
  'UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner',
  () => new UpdateAuthorityMustBeEqualToMetadataAuthorityAndSignerError(),
);

/**
 * MintMismatch: 'Mint given does not match mint on Metadata'
 *
 * @category Errors
 * @category generated
 */
export class MintMismatchError extends Error {
  readonly code: number = 0xf;
  readonly name: string = 'MintMismatch';
  constructor() {
    super('Mint given does not match mint on Metadata');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, MintMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0xf, () => new MintMismatchError());
createErrorFromNameLookup.set('MintMismatch', () => new MintMismatchError());

/**
 * EditionsMustHaveExactlyOneToken: 'Editions must have exactly one token'
 *
 * @category Errors
 * @category generated
 */
export class EditionsMustHaveExactlyOneTokenError extends Error {
  readonly code: number = 0x10;
  readonly name: string = 'EditionsMustHaveExactlyOneToken';
  constructor() {
    super('Editions must have exactly one token');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, EditionsMustHaveExactlyOneTokenError);
    }
  }
}

createErrorFromCodeLookup.set(0x10, () => new EditionsMustHaveExactlyOneTokenError());
createErrorFromNameLookup.set(
  'EditionsMustHaveExactlyOneToken',
  () => new EditionsMustHaveExactlyOneTokenError(),
);

/**
 * MaxEditionsMintedAlready: ''
 *
 * @category Errors
 * @category generated
 */
export class MaxEditionsMintedAlreadyError extends Error {
  readonly code: number = 0x11;
  readonly name: string = 'MaxEditionsMintedAlready';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, MaxEditionsMintedAlreadyError);
    }
  }
}

createErrorFromCodeLookup.set(0x11, () => new MaxEditionsMintedAlreadyError());
createErrorFromNameLookup.set(
  'MaxEditionsMintedAlready',
  () => new MaxEditionsMintedAlreadyError(),
);

/**
 * TokenMintToFailed: ''
 *
 * @category Errors
 * @category generated
 */
export class TokenMintToFailedError extends Error {
  readonly code: number = 0x12;
  readonly name: string = 'TokenMintToFailed';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TokenMintToFailedError);
    }
  }
}

createErrorFromCodeLookup.set(0x12, () => new TokenMintToFailedError());
createErrorFromNameLookup.set('TokenMintToFailed', () => new TokenMintToFailedError());

/**
 * MasterRecordMismatch: ''
 *
 * @category Errors
 * @category generated
 */
export class MasterRecordMismatchError extends Error {
  readonly code: number = 0x13;
  readonly name: string = 'MasterRecordMismatch';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, MasterRecordMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x13, () => new MasterRecordMismatchError());
createErrorFromNameLookup.set('MasterRecordMismatch', () => new MasterRecordMismatchError());

/**
 * DestinationMintMismatch: ''
 *
 * @category Errors
 * @category generated
 */
export class DestinationMintMismatchError extends Error {
  readonly code: number = 0x14;
  readonly name: string = 'DestinationMintMismatch';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, DestinationMintMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x14, () => new DestinationMintMismatchError());
createErrorFromNameLookup.set('DestinationMintMismatch', () => new DestinationMintMismatchError());

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

createErrorFromCodeLookup.set(0x15, () => new EditionAlreadyMintedError());
createErrorFromNameLookup.set('EditionAlreadyMinted', () => new EditionAlreadyMintedError());

/**
 * PrintingMintDecimalsShouldBeZero: ''
 *
 * @category Errors
 * @category generated
 */
export class PrintingMintDecimalsShouldBeZeroError extends Error {
  readonly code: number = 0x16;
  readonly name: string = 'PrintingMintDecimalsShouldBeZero';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, PrintingMintDecimalsShouldBeZeroError);
    }
  }
}

createErrorFromCodeLookup.set(0x16, () => new PrintingMintDecimalsShouldBeZeroError());
createErrorFromNameLookup.set(
  'PrintingMintDecimalsShouldBeZero',
  () => new PrintingMintDecimalsShouldBeZeroError(),
);

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

createErrorFromCodeLookup.set(
  0x17,
  () => new OneTimePrintingAuthorizationMintDecimalsShouldBeZeroError(),
);
createErrorFromNameLookup.set(
  'OneTimePrintingAuthorizationMintDecimalsShouldBeZero',
  () => new OneTimePrintingAuthorizationMintDecimalsShouldBeZeroError(),
);

/**
 * EditionMintDecimalsShouldBeZero: 'EditionMintDecimalsShouldBeZero'
 *
 * @category Errors
 * @category generated
 */
export class EditionMintDecimalsShouldBeZeroError extends Error {
  readonly code: number = 0x18;
  readonly name: string = 'EditionMintDecimalsShouldBeZero';
  constructor() {
    super('EditionMintDecimalsShouldBeZero');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, EditionMintDecimalsShouldBeZeroError);
    }
  }
}

createErrorFromCodeLookup.set(0x18, () => new EditionMintDecimalsShouldBeZeroError());
createErrorFromNameLookup.set(
  'EditionMintDecimalsShouldBeZero',
  () => new EditionMintDecimalsShouldBeZeroError(),
);

/**
 * TokenBurnFailed: ''
 *
 * @category Errors
 * @category generated
 */
export class TokenBurnFailedError extends Error {
  readonly code: number = 0x19;
  readonly name: string = 'TokenBurnFailed';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TokenBurnFailedError);
    }
  }
}

createErrorFromCodeLookup.set(0x19, () => new TokenBurnFailedError());
createErrorFromNameLookup.set('TokenBurnFailed', () => new TokenBurnFailedError());

/**
 * TokenAccountOneTimeAuthMintMismatch: ''
 *
 * @category Errors
 * @category generated
 */
export class TokenAccountOneTimeAuthMintMismatchError extends Error {
  readonly code: number = 0x1a;
  readonly name: string = 'TokenAccountOneTimeAuthMintMismatch';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TokenAccountOneTimeAuthMintMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x1a, () => new TokenAccountOneTimeAuthMintMismatchError());
createErrorFromNameLookup.set(
  'TokenAccountOneTimeAuthMintMismatch',
  () => new TokenAccountOneTimeAuthMintMismatchError(),
);

/**
 * DerivedKeyInvalid: 'Derived key invalid'
 *
 * @category Errors
 * @category generated
 */
export class DerivedKeyInvalidError extends Error {
  readonly code: number = 0x1b;
  readonly name: string = 'DerivedKeyInvalid';
  constructor() {
    super('Derived key invalid');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, DerivedKeyInvalidError);
    }
  }
}

createErrorFromCodeLookup.set(0x1b, () => new DerivedKeyInvalidError());
createErrorFromNameLookup.set('DerivedKeyInvalid', () => new DerivedKeyInvalidError());

/**
 * PrintingMintMismatch: 'The Printing mint does not match that on the master edition!'
 *
 * @category Errors
 * @category generated
 */
export class PrintingMintMismatchError extends Error {
  readonly code: number = 0x1c;
  readonly name: string = 'PrintingMintMismatch';
  constructor() {
    super('The Printing mint does not match that on the master edition!');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, PrintingMintMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x1c, () => new PrintingMintMismatchError());
createErrorFromNameLookup.set('PrintingMintMismatch', () => new PrintingMintMismatchError());

/**
 * OneTimePrintingAuthMintMismatch: 'The One Time Printing Auth mint does not match that on the master edition!'
 *
 * @category Errors
 * @category generated
 */
export class OneTimePrintingAuthMintMismatchError extends Error {
  readonly code: number = 0x1d;
  readonly name: string = 'OneTimePrintingAuthMintMismatch';
  constructor() {
    super('The One Time Printing Auth mint does not match that on the master edition!');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, OneTimePrintingAuthMintMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x1d, () => new OneTimePrintingAuthMintMismatchError());
createErrorFromNameLookup.set(
  'OneTimePrintingAuthMintMismatch',
  () => new OneTimePrintingAuthMintMismatchError(),
);

/**
 * TokenAccountMintMismatch: 'The mint of the token account does not match the Printing mint!'
 *
 * @category Errors
 * @category generated
 */
export class TokenAccountMintMismatchError extends Error {
  readonly code: number = 0x1e;
  readonly name: string = 'TokenAccountMintMismatch';
  constructor() {
    super('The mint of the token account does not match the Printing mint!');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TokenAccountMintMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x1e, () => new TokenAccountMintMismatchError());
createErrorFromNameLookup.set(
  'TokenAccountMintMismatch',
  () => new TokenAccountMintMismatchError(),
);

/**
 * TokenAccountMintMismatchV2: 'The mint of the token account does not match the master metadata mint!'
 *
 * @category Errors
 * @category generated
 */
export class TokenAccountMintMismatchV2Error extends Error {
  readonly code: number = 0x1f;
  readonly name: string = 'TokenAccountMintMismatchV2';
  constructor() {
    super('The mint of the token account does not match the master metadata mint!');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TokenAccountMintMismatchV2Error);
    }
  }
}

createErrorFromCodeLookup.set(0x1f, () => new TokenAccountMintMismatchV2Error());
createErrorFromNameLookup.set(
  'TokenAccountMintMismatchV2',
  () => new TokenAccountMintMismatchV2Error(),
);

/**
 * NotEnoughTokens: 'Not enough tokens to mint a limited edition'
 *
 * @category Errors
 * @category generated
 */
export class NotEnoughTokensError extends Error {
  readonly code: number = 0x20;
  readonly name: string = 'NotEnoughTokens';
  constructor() {
    super('Not enough tokens to mint a limited edition');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotEnoughTokensError);
    }
  }
}

createErrorFromCodeLookup.set(0x20, () => new NotEnoughTokensError());
createErrorFromNameLookup.set('NotEnoughTokens', () => new NotEnoughTokensError());

/**
 * PrintingMintAuthorizationAccountMismatch: ''
 *
 * @category Errors
 * @category generated
 */
export class PrintingMintAuthorizationAccountMismatchError extends Error {
  readonly code: number = 0x21;
  readonly name: string = 'PrintingMintAuthorizationAccountMismatch';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, PrintingMintAuthorizationAccountMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x21, () => new PrintingMintAuthorizationAccountMismatchError());
createErrorFromNameLookup.set(
  'PrintingMintAuthorizationAccountMismatch',
  () => new PrintingMintAuthorizationAccountMismatchError(),
);

/**
 * AuthorizationTokenAccountOwnerMismatch: ''
 *
 * @category Errors
 * @category generated
 */
export class AuthorizationTokenAccountOwnerMismatchError extends Error {
  readonly code: number = 0x22;
  readonly name: string = 'AuthorizationTokenAccountOwnerMismatch';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AuthorizationTokenAccountOwnerMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x22, () => new AuthorizationTokenAccountOwnerMismatchError());
createErrorFromNameLookup.set(
  'AuthorizationTokenAccountOwnerMismatch',
  () => new AuthorizationTokenAccountOwnerMismatchError(),
);

/**
 * Disabled: ''
 *
 * @category Errors
 * @category generated
 */
export class DisabledError extends Error {
  readonly code: number = 0x23;
  readonly name: string = 'Disabled';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, DisabledError);
    }
  }
}

createErrorFromCodeLookup.set(0x23, () => new DisabledError());
createErrorFromNameLookup.set('Disabled', () => new DisabledError());

/**
 * CreatorsTooLong: 'Creators list too long'
 *
 * @category Errors
 * @category generated
 */
export class CreatorsTooLongError extends Error {
  readonly code: number = 0x24;
  readonly name: string = 'CreatorsTooLong';
  constructor() {
    super('Creators list too long');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, CreatorsTooLongError);
    }
  }
}

createErrorFromCodeLookup.set(0x24, () => new CreatorsTooLongError());
createErrorFromNameLookup.set('CreatorsTooLong', () => new CreatorsTooLongError());

/**
 * CreatorsMustBeAtleastOne: 'Creators must be at least one if set'
 *
 * @category Errors
 * @category generated
 */
export class CreatorsMustBeAtleastOneError extends Error {
  readonly code: number = 0x25;
  readonly name: string = 'CreatorsMustBeAtleastOne';
  constructor() {
    super('Creators must be at least one if set');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, CreatorsMustBeAtleastOneError);
    }
  }
}

createErrorFromCodeLookup.set(0x25, () => new CreatorsMustBeAtleastOneError());
createErrorFromNameLookup.set(
  'CreatorsMustBeAtleastOne',
  () => new CreatorsMustBeAtleastOneError(),
);

/**
 * MustBeOneOfCreators: ''
 *
 * @category Errors
 * @category generated
 */
export class MustBeOneOfCreatorsError extends Error {
  readonly code: number = 0x26;
  readonly name: string = 'MustBeOneOfCreators';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, MustBeOneOfCreatorsError);
    }
  }
}

createErrorFromCodeLookup.set(0x26, () => new MustBeOneOfCreatorsError());
createErrorFromNameLookup.set('MustBeOneOfCreators', () => new MustBeOneOfCreatorsError());

/**
 * NoCreatorsPresentOnMetadata: 'This metadata does not have creators'
 *
 * @category Errors
 * @category generated
 */
export class NoCreatorsPresentOnMetadataError extends Error {
  readonly code: number = 0x27;
  readonly name: string = 'NoCreatorsPresentOnMetadata';
  constructor() {
    super('This metadata does not have creators');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NoCreatorsPresentOnMetadataError);
    }
  }
}

createErrorFromCodeLookup.set(0x27, () => new NoCreatorsPresentOnMetadataError());
createErrorFromNameLookup.set(
  'NoCreatorsPresentOnMetadata',
  () => new NoCreatorsPresentOnMetadataError(),
);

/**
 * CreatorNotFound: 'This creator address was not found'
 *
 * @category Errors
 * @category generated
 */
export class CreatorNotFoundError extends Error {
  readonly code: number = 0x28;
  readonly name: string = 'CreatorNotFound';
  constructor() {
    super('This creator address was not found');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, CreatorNotFoundError);
    }
  }
}

createErrorFromCodeLookup.set(0x28, () => new CreatorNotFoundError());
createErrorFromNameLookup.set('CreatorNotFound', () => new CreatorNotFoundError());

/**
 * InvalidBasisPoints: 'Basis points cannot be more than 10000'
 *
 * @category Errors
 * @category generated
 */
export class InvalidBasisPointsError extends Error {
  readonly code: number = 0x29;
  readonly name: string = 'InvalidBasisPoints';
  constructor() {
    super('Basis points cannot be more than 10000');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidBasisPointsError);
    }
  }
}

createErrorFromCodeLookup.set(0x29, () => new InvalidBasisPointsError());
createErrorFromNameLookup.set('InvalidBasisPoints', () => new InvalidBasisPointsError());

/**
 * PrimarySaleCanOnlyBeFlippedToTrue: 'Primary sale can only be flipped to true and is immutable'
 *
 * @category Errors
 * @category generated
 */
export class PrimarySaleCanOnlyBeFlippedToTrueError extends Error {
  readonly code: number = 0x2a;
  readonly name: string = 'PrimarySaleCanOnlyBeFlippedToTrue';
  constructor() {
    super('Primary sale can only be flipped to true and is immutable');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, PrimarySaleCanOnlyBeFlippedToTrueError);
    }
  }
}

createErrorFromCodeLookup.set(0x2a, () => new PrimarySaleCanOnlyBeFlippedToTrueError());
createErrorFromNameLookup.set(
  'PrimarySaleCanOnlyBeFlippedToTrue',
  () => new PrimarySaleCanOnlyBeFlippedToTrueError(),
);

/**
 * OwnerMismatch: 'Owner does not match that on the account given'
 *
 * @category Errors
 * @category generated
 */
export class OwnerMismatchError extends Error {
  readonly code: number = 0x2b;
  readonly name: string = 'OwnerMismatch';
  constructor() {
    super('Owner does not match that on the account given');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, OwnerMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x2b, () => new OwnerMismatchError());
createErrorFromNameLookup.set('OwnerMismatch', () => new OwnerMismatchError());

/**
 * NoBalanceInAccountForAuthorization: 'This account has no tokens to be used for authorization'
 *
 * @category Errors
 * @category generated
 */
export class NoBalanceInAccountForAuthorizationError extends Error {
  readonly code: number = 0x2c;
  readonly name: string = 'NoBalanceInAccountForAuthorization';
  constructor() {
    super('This account has no tokens to be used for authorization');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NoBalanceInAccountForAuthorizationError);
    }
  }
}

createErrorFromCodeLookup.set(0x2c, () => new NoBalanceInAccountForAuthorizationError());
createErrorFromNameLookup.set(
  'NoBalanceInAccountForAuthorization',
  () => new NoBalanceInAccountForAuthorizationError(),
);

/**
 * ShareTotalMustBe100: 'Share total must equal 100 for creator array'
 *
 * @category Errors
 * @category generated
 */
export class ShareTotalMustBe100Error extends Error {
  readonly code: number = 0x2d;
  readonly name: string = 'ShareTotalMustBe100';
  constructor() {
    super('Share total must equal 100 for creator array');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ShareTotalMustBe100Error);
    }
  }
}

createErrorFromCodeLookup.set(0x2d, () => new ShareTotalMustBe100Error());
createErrorFromNameLookup.set('ShareTotalMustBe100', () => new ShareTotalMustBe100Error());

/**
 * ReservationExists: ''
 *
 * @category Errors
 * @category generated
 */
export class ReservationExistsError extends Error {
  readonly code: number = 0x2e;
  readonly name: string = 'ReservationExists';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ReservationExistsError);
    }
  }
}

createErrorFromCodeLookup.set(0x2e, () => new ReservationExistsError());
createErrorFromNameLookup.set('ReservationExists', () => new ReservationExistsError());

/**
 * ReservationDoesNotExist: ''
 *
 * @category Errors
 * @category generated
 */
export class ReservationDoesNotExistError extends Error {
  readonly code: number = 0x2f;
  readonly name: string = 'ReservationDoesNotExist';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ReservationDoesNotExistError);
    }
  }
}

createErrorFromCodeLookup.set(0x2f, () => new ReservationDoesNotExistError());
createErrorFromNameLookup.set('ReservationDoesNotExist', () => new ReservationDoesNotExistError());

/**
 * ReservationNotSet: ''
 *
 * @category Errors
 * @category generated
 */
export class ReservationNotSetError extends Error {
  readonly code: number = 0x30;
  readonly name: string = 'ReservationNotSet';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ReservationNotSetError);
    }
  }
}

createErrorFromCodeLookup.set(0x30, () => new ReservationNotSetError());
createErrorFromNameLookup.set('ReservationNotSet', () => new ReservationNotSetError());

/**
 * ReservationAlreadyMade: ''
 *
 * @category Errors
 * @category generated
 */
export class ReservationAlreadyMadeError extends Error {
  readonly code: number = 0x31;
  readonly name: string = 'ReservationAlreadyMade';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ReservationAlreadyMadeError);
    }
  }
}

createErrorFromCodeLookup.set(0x31, () => new ReservationAlreadyMadeError());
createErrorFromNameLookup.set('ReservationAlreadyMade', () => new ReservationAlreadyMadeError());

/**
 * BeyondMaxAddressSize: ''
 *
 * @category Errors
 * @category generated
 */
export class BeyondMaxAddressSizeError extends Error {
  readonly code: number = 0x32;
  readonly name: string = 'BeyondMaxAddressSize';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, BeyondMaxAddressSizeError);
    }
  }
}

createErrorFromCodeLookup.set(0x32, () => new BeyondMaxAddressSizeError());
createErrorFromNameLookup.set('BeyondMaxAddressSize', () => new BeyondMaxAddressSizeError());

/**
 * NumericalOverflowError: 'NumericalOverflowError'
 *
 * @category Errors
 * @category generated
 */
export class NumericalOverflowErrorError extends Error {
  readonly code: number = 0x33;
  readonly name: string = 'NumericalOverflowError';
  constructor() {
    super('NumericalOverflowError');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NumericalOverflowErrorError);
    }
  }
}

createErrorFromCodeLookup.set(0x33, () => new NumericalOverflowErrorError());
createErrorFromNameLookup.set('NumericalOverflowError', () => new NumericalOverflowErrorError());

/**
 * ReservationBreachesMaximumSupply: ''
 *
 * @category Errors
 * @category generated
 */
export class ReservationBreachesMaximumSupplyError extends Error {
  readonly code: number = 0x34;
  readonly name: string = 'ReservationBreachesMaximumSupply';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ReservationBreachesMaximumSupplyError);
    }
  }
}

createErrorFromCodeLookup.set(0x34, () => new ReservationBreachesMaximumSupplyError());
createErrorFromNameLookup.set(
  'ReservationBreachesMaximumSupply',
  () => new ReservationBreachesMaximumSupplyError(),
);

/**
 * AddressNotInReservation: ''
 *
 * @category Errors
 * @category generated
 */
export class AddressNotInReservationError extends Error {
  readonly code: number = 0x35;
  readonly name: string = 'AddressNotInReservation';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AddressNotInReservationError);
    }
  }
}

createErrorFromCodeLookup.set(0x35, () => new AddressNotInReservationError());
createErrorFromNameLookup.set('AddressNotInReservation', () => new AddressNotInReservationError());

/**
 * CannotVerifyAnotherCreator: 'You cannot unilaterally verify another creator, they must sign'
 *
 * @category Errors
 * @category generated
 */
export class CannotVerifyAnotherCreatorError extends Error {
  readonly code: number = 0x36;
  readonly name: string = 'CannotVerifyAnotherCreator';
  constructor() {
    super('You cannot unilaterally verify another creator, they must sign');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, CannotVerifyAnotherCreatorError);
    }
  }
}

createErrorFromCodeLookup.set(0x36, () => new CannotVerifyAnotherCreatorError());
createErrorFromNameLookup.set(
  'CannotVerifyAnotherCreator',
  () => new CannotVerifyAnotherCreatorError(),
);

/**
 * CannotUnverifyAnotherCreator: 'You cannot unilaterally unverify another creator'
 *
 * @category Errors
 * @category generated
 */
export class CannotUnverifyAnotherCreatorError extends Error {
  readonly code: number = 0x37;
  readonly name: string = 'CannotUnverifyAnotherCreator';
  constructor() {
    super('You cannot unilaterally unverify another creator');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, CannotUnverifyAnotherCreatorError);
    }
  }
}

createErrorFromCodeLookup.set(0x37, () => new CannotUnverifyAnotherCreatorError());
createErrorFromNameLookup.set(
  'CannotUnverifyAnotherCreator',
  () => new CannotUnverifyAnotherCreatorError(),
);

/**
 * SpotMismatch: ''
 *
 * @category Errors
 * @category generated
 */
export class SpotMismatchError extends Error {
  readonly code: number = 0x38;
  readonly name: string = 'SpotMismatch';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, SpotMismatchError);
    }
  }
}

createErrorFromCodeLookup.set(0x38, () => new SpotMismatchError());
createErrorFromNameLookup.set('SpotMismatch', () => new SpotMismatchError());

/**
 * IncorrectOwner: 'Incorrect account owner'
 *
 * @category Errors
 * @category generated
 */
export class IncorrectOwnerError extends Error {
  readonly code: number = 0x39;
  readonly name: string = 'IncorrectOwner';
  constructor() {
    super('Incorrect account owner');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, IncorrectOwnerError);
    }
  }
}

createErrorFromCodeLookup.set(0x39, () => new IncorrectOwnerError());
createErrorFromNameLookup.set('IncorrectOwner', () => new IncorrectOwnerError());

/**
 * PrintingWouldBreachMaximumSupply: ''
 *
 * @category Errors
 * @category generated
 */
export class PrintingWouldBreachMaximumSupplyError extends Error {
  readonly code: number = 0x3a;
  readonly name: string = 'PrintingWouldBreachMaximumSupply';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, PrintingWouldBreachMaximumSupplyError);
    }
  }
}

createErrorFromCodeLookup.set(0x3a, () => new PrintingWouldBreachMaximumSupplyError());
createErrorFromNameLookup.set(
  'PrintingWouldBreachMaximumSupply',
  () => new PrintingWouldBreachMaximumSupplyError(),
);

/**
 * DataIsImmutable: 'Data is immutable'
 *
 * @category Errors
 * @category generated
 */
export class DataIsImmutableError extends Error {
  readonly code: number = 0x3b;
  readonly name: string = 'DataIsImmutable';
  constructor() {
    super('Data is immutable');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, DataIsImmutableError);
    }
  }
}

createErrorFromCodeLookup.set(0x3b, () => new DataIsImmutableError());
createErrorFromNameLookup.set('DataIsImmutable', () => new DataIsImmutableError());

/**
 * DuplicateCreatorAddress: 'No duplicate creator addresses'
 *
 * @category Errors
 * @category generated
 */
export class DuplicateCreatorAddressError extends Error {
  readonly code: number = 0x3c;
  readonly name: string = 'DuplicateCreatorAddress';
  constructor() {
    super('No duplicate creator addresses');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, DuplicateCreatorAddressError);
    }
  }
}

createErrorFromCodeLookup.set(0x3c, () => new DuplicateCreatorAddressError());
createErrorFromNameLookup.set('DuplicateCreatorAddress', () => new DuplicateCreatorAddressError());

/**
 * ReservationSpotsRemainingShouldMatchTotalSpotsAtStart: ''
 *
 * @category Errors
 * @category generated
 */
export class ReservationSpotsRemainingShouldMatchTotalSpotsAtStartError extends Error {
  readonly code: number = 0x3d;
  readonly name: string = 'ReservationSpotsRemainingShouldMatchTotalSpotsAtStart';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ReservationSpotsRemainingShouldMatchTotalSpotsAtStartError);
    }
  }
}

createErrorFromCodeLookup.set(
  0x3d,
  () => new ReservationSpotsRemainingShouldMatchTotalSpotsAtStartError(),
);
createErrorFromNameLookup.set(
  'ReservationSpotsRemainingShouldMatchTotalSpotsAtStart',
  () => new ReservationSpotsRemainingShouldMatchTotalSpotsAtStartError(),
);

/**
 * InvalidTokenProgram: 'Invalid token program'
 *
 * @category Errors
 * @category generated
 */
export class InvalidTokenProgramError extends Error {
  readonly code: number = 0x3e;
  readonly name: string = 'InvalidTokenProgram';
  constructor() {
    super('Invalid token program');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidTokenProgramError);
    }
  }
}

createErrorFromCodeLookup.set(0x3e, () => new InvalidTokenProgramError());
createErrorFromNameLookup.set('InvalidTokenProgram', () => new InvalidTokenProgramError());

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

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

/**
 * BeyondAlottedAddressSize: ''
 *
 * @category Errors
 * @category generated
 */
export class BeyondAlottedAddressSizeError extends Error {
  readonly code: number = 0x40;
  readonly name: string = 'BeyondAlottedAddressSize';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, BeyondAlottedAddressSizeError);
    }
  }
}

createErrorFromCodeLookup.set(0x40, () => new BeyondAlottedAddressSizeError());
createErrorFromNameLookup.set(
  'BeyondAlottedAddressSize',
  () => new BeyondAlottedAddressSizeError(),
);

/**
 * ReservationNotComplete: ''
 *
 * @category Errors
 * @category generated
 */
export class ReservationNotCompleteError extends Error {
  readonly code: number = 0x41;
  readonly name: string = 'ReservationNotComplete';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ReservationNotCompleteError);
    }
  }
}

createErrorFromCodeLookup.set(0x41, () => new ReservationNotCompleteError());
createErrorFromNameLookup.set('ReservationNotComplete', () => new ReservationNotCompleteError());

/**
 * TriedToReplaceAnExistingReservation: ''
 *
 * @category Errors
 * @category generated
 */
export class TriedToReplaceAnExistingReservationError extends Error {
  readonly code: number = 0x42;
  readonly name: string = 'TriedToReplaceAnExistingReservation';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TriedToReplaceAnExistingReservationError);
    }
  }
}

createErrorFromCodeLookup.set(0x42, () => new TriedToReplaceAnExistingReservationError());
createErrorFromNameLookup.set(
  'TriedToReplaceAnExistingReservation',
  () => new TriedToReplaceAnExistingReservationError(),
);

/**
 * InvalidOperation: 'Invalid operation'
 *
 * @category Errors
 * @category generated
 */
export class InvalidOperationError extends Error {
  readonly code: number = 0x43;
  readonly name: string = 'InvalidOperation';
  constructor() {
    super('Invalid operation');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidOperationError);
    }
  }
}

createErrorFromCodeLookup.set(0x43, () => new InvalidOperationError());
createErrorFromNameLookup.set('InvalidOperation', () => new InvalidOperationError());

/**
 * InvalidOwner: 'Invalid Owner'
 *
 * @category Errors
 * @category generated
 */
export class InvalidOwnerError extends Error {
  readonly code: number = 0x44;
  readonly name: string = 'InvalidOwner';
  constructor() {
    super('Invalid Owner');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidOwnerError);
    }
  }
}

createErrorFromCodeLookup.set(0x44, () => new InvalidOwnerError());
createErrorFromNameLookup.set('InvalidOwner', () => new InvalidOwnerError());

/**
 * PrintingMintSupplyMustBeZeroForConversion: 'Printing mint supply must be zero for conversion'
 *
 * @category Errors
 * @category generated
 */
export class PrintingMintSupplyMustBeZeroForConversionError extends Error {
  readonly code: number = 0x45;
  readonly name: string = 'PrintingMintSupplyMustBeZeroForConversion';
  constructor() {
    super('Printing mint supply must be zero for conversion');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, PrintingMintSupplyMustBeZeroForConversionError);
    }
  }
}

createErrorFromCodeLookup.set(0x45, () => new PrintingMintSupplyMustBeZeroForConversionError());
createErrorFromNameLookup.set(
  'PrintingMintSupplyMustBeZeroForConversion',
  () => new PrintingMintSupplyMustBeZeroForConversionError(),
);

/**
 * OneTimeAuthMintSupplyMustBeZeroForConversion: 'One Time Auth mint supply must be zero for conversion'
 *
 * @category Errors
 * @category generated
 */
export class OneTimeAuthMintSupplyMustBeZeroForConversionError extends Error {
  readonly code: number = 0x46;
  readonly name: string = 'OneTimeAuthMintSupplyMustBeZeroForConversion';
  constructor() {
    super('One Time Auth mint supply must be zero for conversion');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, OneTimeAuthMintSupplyMustBeZeroForConversionError);
    }
  }
}

createErrorFromCodeLookup.set(0x46, () => new OneTimeAuthMintSupplyMustBeZeroForConversionError());
createErrorFromNameLookup.set(
  'OneTimeAuthMintSupplyMustBeZeroForConversion',
  () => new OneTimeAuthMintSupplyMustBeZeroForConversionError(),
);

/**
 * InvalidEditionIndex: 'You tried to insert one edition too many into an edition mark pda'
 *
 * @category Errors
 * @category generated
 */
export class InvalidEditionIndexError extends Error {
  readonly code: number = 0x47;
  readonly name: string = 'InvalidEditionIndex';
  constructor() {
    super('You tried to insert one edition too many into an edition mark pda');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidEditionIndexError);
    }
  }
}

createErrorFromCodeLookup.set(0x47, () => new InvalidEditionIndexError());
createErrorFromNameLookup.set('InvalidEditionIndex', () => new InvalidEditionIndexError());

/**
 * ReservationArrayShouldBeSizeOne: ''
 *
 * @category Errors
 * @category generated
 */
export class ReservationArrayShouldBeSizeOneError extends Error {
  readonly code: number = 0x48;
  readonly name: string = 'ReservationArrayShouldBeSizeOne';
  constructor() {
    super('');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ReservationArrayShouldBeSizeOneError);
    }
  }
}

createErrorFromCodeLookup.set(0x48, () => new ReservationArrayShouldBeSizeOneError());
createErrorFromNameLookup.set(
  'ReservationArrayShouldBeSizeOne',
  () => new ReservationArrayShouldBeSizeOneError(),
);

/**
 * IsMutableCanOnlyBeFlippedToFalse: 'Is Mutable can only be flipped to false'
 *
 * @category Errors
 * @category generated
 */
export class IsMutableCanOnlyBeFlippedToFalseError extends Error {
  readonly code: number = 0x49;
  readonly name: string = 'IsMutableCanOnlyBeFlippedToFalse';
  constructor() {
    super('Is Mutable can only be flipped to false');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, IsMutableCanOnlyBeFlippedToFalseError);
    }
  }
}

createErrorFromCodeLookup.set(0x49, () => new IsMutableCanOnlyBeFlippedToFalseError());
createErrorFromNameLookup.set(
  'IsMutableCanOnlyBeFlippedToFalse',
  () => new IsMutableCanOnlyBeFlippedToFalseError(),
);

/**
 * CollectionCannotBeVerifiedInThisInstruction: 'Collection cannot be verified in this instruction'
 *
 * @category Errors
 * @category generated
 */
export class CollectionCannotBeVerifiedInThisInstructionError extends Error {
  readonly code: number = 0x4a;
  readonly name: string = 'CollectionCannotBeVerifiedInThisInstruction';
  constructor() {
    super('Collection cannot be verified in this instruction');
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, CollectionCannotBeVerifiedInThisInstructionError);
    }
  }
}

createErrorFromCodeLookup.set(0x4a, () => new CollectionCannotBeVerifiedInThisInstructionError());
createErrorFromNameLookup.set(
  'CollectionCannotBeVerifiedInThisInstruction',
  () => new CollectionCannotBeVerifiedInThisInstructionError(),
);

/**
 * Removed: 'This instruction was deprecated in a previous release and is now removed'
 *
 * @category Errors
 * @category generated
 */
export class RemovedError extends Error {
  readonly code: number = 0x4b;
  readonly name: string = 'Removed';
  constructor() {
    super('This instruction was deprecated in a previous release and i