@solana/subscriptions 0.0.0 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,3576 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccountDiscriminator: () => AccountDiscriminator,
+  CANCEL_SUBSCRIPTION_DISCRIMINATOR: () => CANCEL_SUBSCRIPTION_DISCRIMINATOR,
+  CLOSE_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR: () => CLOSE_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR,
+  CREATE_FIXED_DELEGATION_DISCRIMINATOR: () => CREATE_FIXED_DELEGATION_DISCRIMINATOR,
+  CREATE_PLAN_DISCRIMINATOR: () => CREATE_PLAN_DISCRIMINATOR,
+  CREATE_RECURRING_DELEGATION_DISCRIMINATOR: () => CREATE_RECURRING_DELEGATION_DISCRIMINATOR,
+  CURRENT_PROGRAM_VERSION: () => CURRENT_PROGRAM_VERSION,
+  DELEGATEE_OFFSET: () => DELEGATEE_OFFSET,
+  DELEGATION_SEED: () => DELEGATION_SEED,
+  DELEGATOR_OFFSET: () => DELEGATOR_OFFSET,
+  DELETE_PLAN_DISCRIMINATOR: () => DELETE_PLAN_DISCRIMINATOR,
+  DISCRIMINATOR_OFFSET: () => DISCRIMINATOR_OFFSET,
+  EVENT_AUTHORITY_SEED: () => EVENT_AUTHORITY_SEED,
+  INIT_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR: () => INIT_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR,
+  MAX_PLAN_DESTINATIONS: () => MAX_PLAN_DESTINATIONS,
+  MAX_PLAN_PULLERS: () => MAX_PLAN_PULLERS,
+  METADATA_URI_LEN: () => METADATA_URI_LEN,
+  PLAN_OWNER_OFFSET: () => PLAN_OWNER_OFFSET,
+  PLAN_SEED: () => PLAN_SEED,
+  PLAN_SIZE: () => PLAN_SIZE,
+  PROGRAM_ID: () => PROGRAM_ID,
+  PlanStatus: () => PlanStatus,
+  RESUME_SUBSCRIPTION_DISCRIMINATOR: () => RESUME_SUBSCRIPTION_DISCRIMINATOR,
+  REVOKE_DELEGATION_DISCRIMINATOR: () => REVOKE_DELEGATION_DISCRIMINATOR,
+  SUBSCRIBE_DISCRIMINATOR: () => SUBSCRIBE_DISCRIMINATOR,
+  SUBSCRIPTIONS_ERROR__ACCOUNT_NOT_WRITABLE: () => SUBSCRIPTIONS_ERROR__ACCOUNT_NOT_WRITABLE,
+  SUBSCRIPTIONS_ERROR__ALREADY_SUBSCRIBED: () => SUBSCRIPTIONS_ERROR__ALREADY_SUBSCRIBED,
+  SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_LIMIT: () => SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_LIMIT,
+  SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_PERIOD_LIMIT: () => SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_PERIOD_LIMIT,
+  SUBSCRIPTIONS_ERROR__ARITHMETIC_OVERFLOW: () => SUBSCRIPTIONS_ERROR__ARITHMETIC_OVERFLOW,
+  SUBSCRIPTIONS_ERROR__ARITHMETIC_UNDERFLOW: () => SUBSCRIPTIONS_ERROR__ARITHMETIC_UNDERFLOW,
+  SUBSCRIPTIONS_ERROR__ATA_OWNER_MISMATCH: () => SUBSCRIPTIONS_ERROR__ATA_OWNER_MISMATCH,
+  SUBSCRIPTIONS_ERROR__DELEGATION_ALREADY_EXISTS: () => SUBSCRIPTIONS_ERROR__DELEGATION_ALREADY_EXISTS,
+  SUBSCRIPTIONS_ERROR__DELEGATION_EXPIRED: () => SUBSCRIPTIONS_ERROR__DELEGATION_EXPIRED,
+  SUBSCRIPTIONS_ERROR__DELEGATION_NOT_STARTED: () => SUBSCRIPTIONS_ERROR__DELEGATION_NOT_STARTED,
+  SUBSCRIPTIONS_ERROR__DELEGATION_VERSION_MISMATCH: () => SUBSCRIPTIONS_ERROR__DELEGATION_VERSION_MISMATCH,
+  SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_AMOUNT_ZERO: () => SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_AMOUNT_ZERO,
+  SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_EXPIRY_IN_PAST: () => SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_EXPIRY_IN_PAST,
+  SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DATA: () => SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DISCRIMINATOR: () => SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DISCRIMINATOR,
+  SUBSCRIPTIONS_ERROR__INVALID_ADDRESS: () => SUBSCRIPTIONS_ERROR__INVALID_ADDRESS,
+  SUBSCRIPTIONS_ERROR__INVALID_AMOUNT: () => SUBSCRIPTIONS_ERROR__INVALID_AMOUNT,
+  SUBSCRIPTIONS_ERROR__INVALID_ASSOCIATED_TOKEN_ACCOUNT_DERIVED_ADDRESS: () => SUBSCRIPTIONS_ERROR__INVALID_ASSOCIATED_TOKEN_ACCOUNT_DERIVED_ADDRESS,
+  SUBSCRIPTIONS_ERROR__INVALID_DELEGATE_PDA: () => SUBSCRIPTIONS_ERROR__INVALID_DELEGATE_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_END_TS: () => SUBSCRIPTIONS_ERROR__INVALID_END_TS,
+  SUBSCRIPTIONS_ERROR__INVALID_ESCROW_PDA: () => SUBSCRIPTIONS_ERROR__INVALID_ESCROW_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_EVENT_AUTHORITY: () => SUBSCRIPTIONS_ERROR__INVALID_EVENT_AUTHORITY,
+  SUBSCRIPTIONS_ERROR__INVALID_EVENT_DATA: () => SUBSCRIPTIONS_ERROR__INVALID_EVENT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_EVENT_DISCRIMINATOR: () => SUBSCRIPTIONS_ERROR__INVALID_EVENT_DISCRIMINATOR,
+  SUBSCRIPTIONS_ERROR__INVALID_EVENT_TAG: () => SUBSCRIPTIONS_ERROR__INVALID_EVENT_TAG,
+  SUBSCRIPTIONS_ERROR__INVALID_HEADER_DATA: () => SUBSCRIPTIONS_ERROR__INVALID_HEADER_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION: () => SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION,
+  SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION_DATA: () => SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_NUM_DESTINATIONS: () => SUBSCRIPTIONS_ERROR__INVALID_NUM_DESTINATIONS,
+  SUBSCRIPTIONS_ERROR__INVALID_PAYER_DATA: () => SUBSCRIPTIONS_ERROR__INVALID_PAYER_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_PERIOD_LENGTH: () => SUBSCRIPTIONS_ERROR__INVALID_PERIOD_LENGTH,
+  SUBSCRIPTIONS_ERROR__INVALID_PLAN_PDA: () => SUBSCRIPTIONS_ERROR__INVALID_PLAN_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_PLAN_STATUS: () => SUBSCRIPTIONS_ERROR__INVALID_PLAN_STATUS,
+  SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_AUTHORITY_PDA: () => SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_AUTHORITY_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_PDA: () => SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_MINT_ACCOUNT_DATA: () => SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_MINT_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_TOKEN_ACCOUNT_DATA: () => SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_TOKEN_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN_PROGRAM: () => SUBSCRIPTIONS_ERROR__INVALID_TOKEN_PROGRAM,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_MINT_ACCOUNT_DATA: () => SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_MINT_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_TOKEN_ACCOUNT_DATA: () => SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_TOKEN_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__MIGRATION_REQUIRED: () => SUBSCRIPTIONS_ERROR__MIGRATION_REQUIRED,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_CONFIDENTIAL_TRANSFER: () => SUBSCRIPTIONS_ERROR__MINT_HAS_CONFIDENTIAL_TRANSFER,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_MINT_CLOSE_AUTHORITY: () => SUBSCRIPTIONS_ERROR__MINT_HAS_MINT_CLOSE_AUTHORITY,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_NON_TRANSFERABLE: () => SUBSCRIPTIONS_ERROR__MINT_HAS_NON_TRANSFERABLE,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_PAUSABLE: () => SUBSCRIPTIONS_ERROR__MINT_HAS_PAUSABLE,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_PERMANENT_DELEGATE: () => SUBSCRIPTIONS_ERROR__MINT_HAS_PERMANENT_DELEGATE,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_FEE: () => SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_FEE,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_HOOK: () => SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_HOOK,
+  SUBSCRIPTIONS_ERROR__MINT_MISMATCH: () => SUBSCRIPTIONS_ERROR__MINT_MISMATCH,
+  SUBSCRIPTIONS_ERROR__NOT_ENOUGH_ACCOUNT_KEYS: () => SUBSCRIPTIONS_ERROR__NOT_ENOUGH_ACCOUNT_KEYS,
+  SUBSCRIPTIONS_ERROR__NOT_PLAN_OWNER: () => SUBSCRIPTIONS_ERROR__NOT_PLAN_OWNER,
+  SUBSCRIPTIONS_ERROR__NOT_SIGNER: () => SUBSCRIPTIONS_ERROR__NOT_SIGNER,
+  SUBSCRIPTIONS_ERROR__NOT_SYSTEM_PROGRAM: () => SUBSCRIPTIONS_ERROR__NOT_SYSTEM_PROGRAM,
+  SUBSCRIPTIONS_ERROR__PERIOD_NOT_ELAPSED: () => SUBSCRIPTIONS_ERROR__PERIOD_NOT_ELAPSED,
+  SUBSCRIPTIONS_ERROR__PLAN_ALREADY_EXISTS: () => SUBSCRIPTIONS_ERROR__PLAN_ALREADY_EXISTS,
+  SUBSCRIPTIONS_ERROR__PLAN_CLOSED: () => SUBSCRIPTIONS_ERROR__PLAN_CLOSED,
+  SUBSCRIPTIONS_ERROR__PLAN_EXPIRED: () => SUBSCRIPTIONS_ERROR__PLAN_EXPIRED,
+  SUBSCRIPTIONS_ERROR__PLAN_IMMUTABLE_AFTER_SUNSET: () => SUBSCRIPTIONS_ERROR__PLAN_IMMUTABLE_AFTER_SUNSET,
+  SUBSCRIPTIONS_ERROR__PLAN_NOT_EXPIRED: () => SUBSCRIPTIONS_ERROR__PLAN_NOT_EXPIRED,
+  SUBSCRIPTIONS_ERROR__PLAN_SUNSET: () => SUBSCRIPTIONS_ERROR__PLAN_SUNSET,
+  SUBSCRIPTIONS_ERROR__PLAN_TERMS_MISMATCH: () => SUBSCRIPTIONS_ERROR__PLAN_TERMS_MISMATCH,
+  SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_AMOUNT_ZERO: () => SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_AMOUNT_ZERO,
+  SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_GREATER_THAN_EXPIRY: () => SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_GREATER_THAN_EXPIRY,
+  SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_IN_PAST: () => SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_IN_PAST,
+  SUBSCRIPTIONS_ERROR__STALE_SUBSCRIPTION_AUTHORITY: () => SUBSCRIPTIONS_ERROR__STALE_SUBSCRIPTION_AUTHORITY,
+  SUBSCRIPTIONS_ERROR__SUBSCRIPTION_ALREADY_CANCELLED: () => SUBSCRIPTIONS_ERROR__SUBSCRIPTION_ALREADY_CANCELLED,
+  SUBSCRIPTIONS_ERROR__SUBSCRIPTION_CANCELLED: () => SUBSCRIPTIONS_ERROR__SUBSCRIPTION_CANCELLED,
+  SUBSCRIPTIONS_ERROR__SUBSCRIPTION_NOT_CANCELLED: () => SUBSCRIPTIONS_ERROR__SUBSCRIPTION_NOT_CANCELLED,
+  SUBSCRIPTIONS_ERROR__SUBSCRIPTION_PLAN_MISMATCH: () => SUBSCRIPTIONS_ERROR__SUBSCRIPTION_PLAN_MISMATCH,
+  SUBSCRIPTIONS_ERROR__SUNSET_REQUIRES_END_TS: () => SUBSCRIPTIONS_ERROR__SUNSET_REQUIRES_END_TS,
+  SUBSCRIPTIONS_ERROR__UNAUTHORIZED: () => SUBSCRIPTIONS_ERROR__UNAUTHORIZED,
+  SUBSCRIPTIONS_ERROR__UNAUTHORIZED_DESTINATION: () => SUBSCRIPTIONS_ERROR__UNAUTHORIZED_DESTINATION,
+  SUBSCRIPTIONS_PROGRAM_ADDRESS: () => SUBSCRIPTIONS_PROGRAM_ADDRESS,
+  SUBSCRIPTION_AUTHORITY_SEED: () => SUBSCRIPTION_AUTHORITY_SEED,
+  SUBSCRIPTION_SEED: () => SUBSCRIPTION_SEED,
+  SUBSCRIPTION_SIZE: () => SUBSCRIPTION_SIZE,
+  SubscriptionsAccount: () => SubscriptionsAccount,
+  SubscriptionsInstruction: () => SubscriptionsInstruction,
+  TRANSFER_FIXED_DISCRIMINATOR: () => TRANSFER_FIXED_DISCRIMINATOR,
+  TRANSFER_RECURRING_DISCRIMINATOR: () => TRANSFER_RECURRING_DISCRIMINATOR,
+  TRANSFER_SUBSCRIPTION_DISCRIMINATOR: () => TRANSFER_SUBSCRIPTION_DISCRIMINATOR,
+  U64_BYTE_SIZE: () => U64_BYTE_SIZE,
+  UPDATE_PLAN_DISCRIMINATOR: () => UPDATE_PLAN_DISCRIMINATOR,
+  ValidationError: () => ValidationError,
+  ZERO_ADDRESS: () => ZERO_ADDRESS,
+  decodeDelegationAccount: () => decodeDelegationAccount,
+  decodeEventAuthority: () => decodeEventAuthority,
+  decodeFixedDelegation: () => decodeFixedDelegation,
+  decodePlan: () => decodePlan,
+  decodeRecurringDelegation: () => decodeRecurringDelegation,
+  decodeSubscriptionAuthority: () => decodeSubscriptionAuthority,
+  decodeSubscriptionDelegation: () => decodeSubscriptionDelegation,
+  fetchAllEventAuthority: () => fetchAllEventAuthority,
+  fetchAllFixedDelegation: () => fetchAllFixedDelegation,
+  fetchAllMaybeEventAuthority: () => fetchAllMaybeEventAuthority,
+  fetchAllMaybeFixedDelegation: () => fetchAllMaybeFixedDelegation,
+  fetchAllMaybePlan: () => fetchAllMaybePlan,
+  fetchAllMaybeRecurringDelegation: () => fetchAllMaybeRecurringDelegation,
+  fetchAllMaybeSubscriptionAuthority: () => fetchAllMaybeSubscriptionAuthority,
+  fetchAllMaybeSubscriptionDelegation: () => fetchAllMaybeSubscriptionDelegation,
+  fetchAllPlan: () => fetchAllPlan,
+  fetchAllRecurringDelegation: () => fetchAllRecurringDelegation,
+  fetchAllSubscriptionAuthority: () => fetchAllSubscriptionAuthority,
+  fetchAllSubscriptionDelegation: () => fetchAllSubscriptionDelegation,
+  fetchDelegationsByDelegatee: () => fetchDelegationsByDelegatee,
+  fetchDelegationsByDelegator: () => fetchDelegationsByDelegator,
+  fetchEventAuthority: () => fetchEventAuthority,
+  fetchEventAuthorityFromSeeds: () => fetchEventAuthorityFromSeeds,
+  fetchFixedDelegation: () => fetchFixedDelegation,
+  fetchFixedDelegationFromSeeds: () => fetchFixedDelegationFromSeeds,
+  fetchMaybeEventAuthority: () => fetchMaybeEventAuthority,
+  fetchMaybeEventAuthorityFromSeeds: () => fetchMaybeEventAuthorityFromSeeds,
+  fetchMaybeFixedDelegation: () => fetchMaybeFixedDelegation,
+  fetchMaybeFixedDelegationFromSeeds: () => fetchMaybeFixedDelegationFromSeeds,
+  fetchMaybePlan: () => fetchMaybePlan,
+  fetchMaybePlanFromSeeds: () => fetchMaybePlanFromSeeds,
+  fetchMaybeRecurringDelegation: () => fetchMaybeRecurringDelegation,
+  fetchMaybeRecurringDelegationFromSeeds: () => fetchMaybeRecurringDelegationFromSeeds,
+  fetchMaybeSubscriptionAuthority: () => fetchMaybeSubscriptionAuthority,
+  fetchMaybeSubscriptionAuthorityFromSeeds: () => fetchMaybeSubscriptionAuthorityFromSeeds,
+  fetchMaybeSubscriptionDelegation: () => fetchMaybeSubscriptionDelegation,
+  fetchMaybeSubscriptionDelegationFromSeeds: () => fetchMaybeSubscriptionDelegationFromSeeds,
+  fetchPlan: () => fetchPlan,
+  fetchPlanFromSeeds: () => fetchPlanFromSeeds,
+  fetchPlansForOwner: () => fetchPlansForOwner,
+  fetchRecurringDelegation: () => fetchRecurringDelegation,
+  fetchRecurringDelegationFromSeeds: () => fetchRecurringDelegationFromSeeds,
+  fetchSubscriptionAuthority: () => fetchSubscriptionAuthority,
+  fetchSubscriptionAuthorityFromSeeds: () => fetchSubscriptionAuthorityFromSeeds,
+  fetchSubscriptionDelegation: () => fetchSubscriptionDelegation,
+  fetchSubscriptionDelegationFromSeeds: () => fetchSubscriptionDelegationFromSeeds,
+  fetchSubscriptionsForUser: () => fetchSubscriptionsForUser,
+  findEventAuthorityPda: () => findEventAuthorityPda,
+  findFixedDelegationPda: () => findFixedDelegationPda,
+  findPlanPda: () => findPlanPda,
+  findRecurringDelegationPda: () => findRecurringDelegationPda,
+  findSubscriptionAuthorityPda: () => findSubscriptionAuthorityPda,
+  findSubscriptionDelegationPda: () => findSubscriptionDelegationPda,
+  getAccountDiscriminatorCodec: () => getAccountDiscriminatorCodec,
+  getAccountDiscriminatorDecoder: () => getAccountDiscriminatorDecoder,
+  getAccountDiscriminatorEncoder: () => getAccountDiscriminatorEncoder,
+  getCancelSubscriptionDiscriminatorBytes: () => getCancelSubscriptionDiscriminatorBytes,
+  getCancelSubscriptionInstruction: () => getCancelSubscriptionInstruction,
+  getCancelSubscriptionInstructionAsync: () => getCancelSubscriptionInstructionAsync,
+  getCancelSubscriptionInstructionDataCodec: () => getCancelSubscriptionInstructionDataCodec,
+  getCancelSubscriptionInstructionDataDecoder: () => getCancelSubscriptionInstructionDataDecoder,
+  getCancelSubscriptionInstructionDataEncoder: () => getCancelSubscriptionInstructionDataEncoder,
+  getCancelSubscriptionOverlayInstructionAsync: () => getCancelSubscriptionOverlayInstructionAsync,
+  getCloseSubscriptionAuthorityDiscriminatorBytes: () => getCloseSubscriptionAuthorityDiscriminatorBytes,
+  getCloseSubscriptionAuthorityInstruction: () => getCloseSubscriptionAuthorityInstruction,
+  getCloseSubscriptionAuthorityInstructionDataCodec: () => getCloseSubscriptionAuthorityInstructionDataCodec,
+  getCloseSubscriptionAuthorityInstructionDataDecoder: () => getCloseSubscriptionAuthorityInstructionDataDecoder,
+  getCloseSubscriptionAuthorityInstructionDataEncoder: () => getCloseSubscriptionAuthorityInstructionDataEncoder,
+  getCloseSubscriptionAuthorityOverlayInstructionAsync: () => getCloseSubscriptionAuthorityOverlayInstructionAsync,
+  getCreateFixedDelegationDataCodec: () => getCreateFixedDelegationDataCodec,
+  getCreateFixedDelegationDataDecoder: () => getCreateFixedDelegationDataDecoder,
+  getCreateFixedDelegationDataEncoder: () => getCreateFixedDelegationDataEncoder,
+  getCreateFixedDelegationDiscriminatorBytes: () => getCreateFixedDelegationDiscriminatorBytes,
+  getCreateFixedDelegationInstruction: () => getCreateFixedDelegationInstruction,
+  getCreateFixedDelegationInstructionDataCodec: () => getCreateFixedDelegationInstructionDataCodec,
+  getCreateFixedDelegationInstructionDataDecoder: () => getCreateFixedDelegationInstructionDataDecoder,
+  getCreateFixedDelegationInstructionDataEncoder: () => getCreateFixedDelegationInstructionDataEncoder,
+  getCreateFixedDelegationOverlayInstructionAsync: () => getCreateFixedDelegationOverlayInstructionAsync,
+  getCreatePlanDiscriminatorBytes: () => getCreatePlanDiscriminatorBytes,
+  getCreatePlanInstruction: () => getCreatePlanInstruction,
+  getCreatePlanInstructionDataCodec: () => getCreatePlanInstructionDataCodec,
+  getCreatePlanInstructionDataDecoder: () => getCreatePlanInstructionDataDecoder,
+  getCreatePlanInstructionDataEncoder: () => getCreatePlanInstructionDataEncoder,
+  getCreatePlanOverlayInstructionAsync: () => getCreatePlanOverlayInstructionAsync,
+  getCreateRecurringDelegationDataCodec: () => getCreateRecurringDelegationDataCodec,
+  getCreateRecurringDelegationDataDecoder: () => getCreateRecurringDelegationDataDecoder,
+  getCreateRecurringDelegationDataEncoder: () => getCreateRecurringDelegationDataEncoder,
+  getCreateRecurringDelegationDiscriminatorBytes: () => getCreateRecurringDelegationDiscriminatorBytes,
+  getCreateRecurringDelegationInstruction: () => getCreateRecurringDelegationInstruction,
+  getCreateRecurringDelegationInstructionDataCodec: () => getCreateRecurringDelegationInstructionDataCodec,
+  getCreateRecurringDelegationInstructionDataDecoder: () => getCreateRecurringDelegationInstructionDataDecoder,
+  getCreateRecurringDelegationInstructionDataEncoder: () => getCreateRecurringDelegationInstructionDataEncoder,
+  getCreateRecurringDelegationOverlayInstructionAsync: () => getCreateRecurringDelegationOverlayInstructionAsync,
+  getDeletePlanDiscriminatorBytes: () => getDeletePlanDiscriminatorBytes,
+  getDeletePlanInstruction: () => getDeletePlanInstruction,
+  getDeletePlanInstructionDataCodec: () => getDeletePlanInstructionDataCodec,
+  getDeletePlanInstructionDataDecoder: () => getDeletePlanInstructionDataDecoder,
+  getDeletePlanInstructionDataEncoder: () => getDeletePlanInstructionDataEncoder,
+  getDeletePlanOverlayInstruction: () => getDeletePlanOverlayInstruction,
+  getEventAuthorityCodec: () => getEventAuthorityCodec,
+  getEventAuthorityDecoder: () => getEventAuthorityDecoder,
+  getEventAuthorityEncoder: () => getEventAuthorityEncoder,
+  getFixedDelegationCodec: () => getFixedDelegationCodec,
+  getFixedDelegationDecoder: () => getFixedDelegationDecoder,
+  getFixedDelegationEncoder: () => getFixedDelegationEncoder,
+  getHeaderCodec: () => getHeaderCodec,
+  getHeaderDecoder: () => getHeaderDecoder,
+  getHeaderEncoder: () => getHeaderEncoder,
+  getInitSubscriptionAuthorityDiscriminatorBytes: () => getInitSubscriptionAuthorityDiscriminatorBytes,
+  getInitSubscriptionAuthorityInstruction: () => getInitSubscriptionAuthorityInstruction,
+  getInitSubscriptionAuthorityInstructionAsync: () => getInitSubscriptionAuthorityInstructionAsync,
+  getInitSubscriptionAuthorityInstructionDataCodec: () => getInitSubscriptionAuthorityInstructionDataCodec,
+  getInitSubscriptionAuthorityInstructionDataDecoder: () => getInitSubscriptionAuthorityInstructionDataDecoder,
+  getInitSubscriptionAuthorityInstructionDataEncoder: () => getInitSubscriptionAuthorityInstructionDataEncoder,
+  getInitSubscriptionAuthorityOverlayInstructionAsync: () => getInitSubscriptionAuthorityOverlayInstructionAsync,
+  getPlanCodec: () => getPlanCodec,
+  getPlanDataCodec: () => getPlanDataCodec,
+  getPlanDataDecoder: () => getPlanDataDecoder,
+  getPlanDataEncoder: () => getPlanDataEncoder,
+  getPlanDecoder: () => getPlanDecoder,
+  getPlanEncoder: () => getPlanEncoder,
+  getPlanStatusCodec: () => getPlanStatusCodec,
+  getPlanStatusDecoder: () => getPlanStatusDecoder,
+  getPlanStatusEncoder: () => getPlanStatusEncoder,
+  getPlanTermsCodec: () => getPlanTermsCodec,
+  getPlanTermsDecoder: () => getPlanTermsDecoder,
+  getPlanTermsEncoder: () => getPlanTermsEncoder,
+  getRecurringDelegationCodec: () => getRecurringDelegationCodec,
+  getRecurringDelegationDecoder: () => getRecurringDelegationDecoder,
+  getRecurringDelegationEncoder: () => getRecurringDelegationEncoder,
+  getResumeSubscriptionDiscriminatorBytes: () => getResumeSubscriptionDiscriminatorBytes,
+  getResumeSubscriptionInstruction: () => getResumeSubscriptionInstruction,
+  getResumeSubscriptionInstructionAsync: () => getResumeSubscriptionInstructionAsync,
+  getResumeSubscriptionInstructionDataCodec: () => getResumeSubscriptionInstructionDataCodec,
+  getResumeSubscriptionInstructionDataDecoder: () => getResumeSubscriptionInstructionDataDecoder,
+  getResumeSubscriptionInstructionDataEncoder: () => getResumeSubscriptionInstructionDataEncoder,
+  getResumeSubscriptionOverlayInstructionAsync: () => getResumeSubscriptionOverlayInstructionAsync,
+  getRevokeDelegationDiscriminatorBytes: () => getRevokeDelegationDiscriminatorBytes,
+  getRevokeDelegationInstruction: () => getRevokeDelegationInstruction,
+  getRevokeDelegationInstructionDataCodec: () => getRevokeDelegationInstructionDataCodec,
+  getRevokeDelegationInstructionDataDecoder: () => getRevokeDelegationInstructionDataDecoder,
+  getRevokeDelegationInstructionDataEncoder: () => getRevokeDelegationInstructionDataEncoder,
+  getRevokeDelegationOverlayInstruction: () => getRevokeDelegationOverlayInstruction,
+  getRevokeSubscriptionOverlayInstruction: () => getRevokeSubscriptionOverlayInstruction,
+  getSubscribeDataCodec: () => getSubscribeDataCodec,
+  getSubscribeDataDecoder: () => getSubscribeDataDecoder,
+  getSubscribeDataEncoder: () => getSubscribeDataEncoder,
+  getSubscribeDiscriminatorBytes: () => getSubscribeDiscriminatorBytes,
+  getSubscribeInstruction: () => getSubscribeInstruction,
+  getSubscribeInstructionAsync: () => getSubscribeInstructionAsync,
+  getSubscribeInstructionDataCodec: () => getSubscribeInstructionDataCodec,
+  getSubscribeInstructionDataDecoder: () => getSubscribeInstructionDataDecoder,
+  getSubscribeInstructionDataEncoder: () => getSubscribeInstructionDataEncoder,
+  getSubscribeOverlayInstructionAsync: () => getSubscribeOverlayInstructionAsync,
+  getSubscriptionAuthorityCodec: () => getSubscriptionAuthorityCodec,
+  getSubscriptionAuthorityDecoder: () => getSubscriptionAuthorityDecoder,
+  getSubscriptionAuthorityEncoder: () => getSubscriptionAuthorityEncoder,
+  getSubscriptionDelegationCodec: () => getSubscriptionDelegationCodec,
+  getSubscriptionDelegationDecoder: () => getSubscriptionDelegationDecoder,
+  getSubscriptionDelegationEncoder: () => getSubscriptionDelegationEncoder,
+  getSubscriptionsErrorMessage: () => getSubscriptionsErrorMessage,
+  getTransferDataCodec: () => getTransferDataCodec,
+  getTransferDataDecoder: () => getTransferDataDecoder,
+  getTransferDataEncoder: () => getTransferDataEncoder,
+  getTransferFixedDiscriminatorBytes: () => getTransferFixedDiscriminatorBytes,
+  getTransferFixedInstruction: () => getTransferFixedInstruction,
+  getTransferFixedInstructionDataCodec: () => getTransferFixedInstructionDataCodec,
+  getTransferFixedInstructionDataDecoder: () => getTransferFixedInstructionDataDecoder,
+  getTransferFixedInstructionDataEncoder: () => getTransferFixedInstructionDataEncoder,
+  getTransferFixedOverlayInstructionAsync: () => getTransferFixedOverlayInstructionAsync,
+  getTransferRecurringDiscriminatorBytes: () => getTransferRecurringDiscriminatorBytes,
+  getTransferRecurringInstruction: () => getTransferRecurringInstruction,
+  getTransferRecurringInstructionDataCodec: () => getTransferRecurringInstructionDataCodec,
+  getTransferRecurringInstructionDataDecoder: () => getTransferRecurringInstructionDataDecoder,
+  getTransferRecurringInstructionDataEncoder: () => getTransferRecurringInstructionDataEncoder,
+  getTransferRecurringOverlayInstructionAsync: () => getTransferRecurringOverlayInstructionAsync,
+  getTransferSubscriptionDiscriminatorBytes: () => getTransferSubscriptionDiscriminatorBytes,
+  getTransferSubscriptionInstruction: () => getTransferSubscriptionInstruction,
+  getTransferSubscriptionInstructionDataCodec: () => getTransferSubscriptionInstructionDataCodec,
+  getTransferSubscriptionInstructionDataDecoder: () => getTransferSubscriptionInstructionDataDecoder,
+  getTransferSubscriptionInstructionDataEncoder: () => getTransferSubscriptionInstructionDataEncoder,
+  getTransferSubscriptionOverlayInstructionAsync: () => getTransferSubscriptionOverlayInstructionAsync,
+  getUpdatePlanDataCodec: () => getUpdatePlanDataCodec,
+  getUpdatePlanDataDecoder: () => getUpdatePlanDataDecoder,
+  getUpdatePlanDataEncoder: () => getUpdatePlanDataEncoder,
+  getUpdatePlanDiscriminatorBytes: () => getUpdatePlanDiscriminatorBytes,
+  getUpdatePlanInstruction: () => getUpdatePlanInstruction,
+  getUpdatePlanInstructionDataCodec: () => getUpdatePlanInstructionDataCodec,
+  getUpdatePlanInstructionDataDecoder: () => getUpdatePlanInstructionDataDecoder,
+  getUpdatePlanInstructionDataEncoder: () => getUpdatePlanInstructionDataEncoder,
+  getUpdatePlanOverlayInstruction: () => getUpdatePlanOverlayInstruction,
+  identifySubscriptionsInstruction: () => identifySubscriptionsInstruction,
+  isSubscriptionsError: () => isSubscriptionsError,
+  parseCancelSubscriptionInstruction: () => parseCancelSubscriptionInstruction,
+  parseCloseSubscriptionAuthorityInstruction: () => parseCloseSubscriptionAuthorityInstruction,
+  parseCreateFixedDelegationInstruction: () => parseCreateFixedDelegationInstruction,
+  parseCreatePlanInstruction: () => parseCreatePlanInstruction,
+  parseCreateRecurringDelegationInstruction: () => parseCreateRecurringDelegationInstruction,
+  parseDeletePlanInstruction: () => parseDeletePlanInstruction,
+  parseInitSubscriptionAuthorityInstruction: () => parseInitSubscriptionAuthorityInstruction,
+  parseResumeSubscriptionInstruction: () => parseResumeSubscriptionInstruction,
+  parseRevokeDelegationInstruction: () => parseRevokeDelegationInstruction,
+  parseSubscribeInstruction: () => parseSubscribeInstruction,
+  parseSubscriptionsInstruction: () => parseSubscriptionsInstruction,
+  parseTransferFixedInstruction: () => parseTransferFixedInstruction,
+  parseTransferRecurringInstruction: () => parseTransferRecurringInstruction,
+  parseTransferSubscriptionInstruction: () => parseTransferSubscriptionInstruction,
+  parseUpdatePlanInstruction: () => parseUpdatePlanInstruction,
+  subscriptionsProgram: () => subscriptionsProgram2,
+  toEncodedAccount: () => toEncodedAccount
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/accounts/decode.ts
+var import_kit39 = require("@solana/kit");
+
+// src/generated/accounts/eventAuthority.ts
+var import_kit7 = require("@solana/kit");
+
+// src/generated/pdas/eventAuthority.ts
+var import_kit = require("@solana/kit");
+async function findEventAuthorityPda(config = {}) {
+  const {
+    programAddress = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44"
+  } = config;
+  return await (0, import_kit.getProgramDerivedAddress)({ programAddress, seeds: [(0, import_kit.getUtf8Encoder)().encode("event_authority")] });
+}
+
+// src/generated/pdas/fixedDelegation.ts
+var import_kit2 = require("@solana/kit");
+async function findFixedDelegationPda(seeds, config = {}) {
+  const {
+    programAddress = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44"
+  } = config;
+  return await (0, import_kit2.getProgramDerivedAddress)({
+    programAddress,
+    seeds: [
+      (0, import_kit2.getUtf8Encoder)().encode("delegation"),
+      (0, import_kit2.getAddressEncoder)().encode(seeds.subscriptionAuthority),
+      (0, import_kit2.getAddressEncoder)().encode(seeds.delegator),
+      (0, import_kit2.getAddressEncoder)().encode(seeds.delegatee),
+      (0, import_kit2.getU64Encoder)().encode(seeds.nonce)
+    ]
+  });
+}
+
+// src/generated/pdas/plan.ts
+var import_kit3 = require("@solana/kit");
+async function findPlanPda(seeds, config = {}) {
+  const {
+    programAddress = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44"
+  } = config;
+  return await (0, import_kit3.getProgramDerivedAddress)({
+    programAddress,
+    seeds: [
+      (0, import_kit3.getUtf8Encoder)().encode("plan"),
+      (0, import_kit3.getAddressEncoder)().encode(seeds.owner),
+      (0, import_kit3.getU64Encoder)().encode(seeds.planId)
+    ]
+  });
+}
+
+// src/generated/pdas/recurringDelegation.ts
+var import_kit4 = require("@solana/kit");
+async function findRecurringDelegationPda(seeds, config = {}) {
+  const {
+    programAddress = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44"
+  } = config;
+  return await (0, import_kit4.getProgramDerivedAddress)({
+    programAddress,
+    seeds: [
+      (0, import_kit4.getUtf8Encoder)().encode("delegation"),
+      (0, import_kit4.getAddressEncoder)().encode(seeds.subscriptionAuthority),
+      (0, import_kit4.getAddressEncoder)().encode(seeds.delegator),
+      (0, import_kit4.getAddressEncoder)().encode(seeds.delegatee),
+      (0, import_kit4.getU64Encoder)().encode(seeds.nonce)
+    ]
+  });
+}
+
+// src/generated/pdas/subscriptionAuthority.ts
+var import_kit5 = require("@solana/kit");
+async function findSubscriptionAuthorityPda(seeds, config = {}) {
+  const {
+    programAddress = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44"
+  } = config;
+  return await (0, import_kit5.getProgramDerivedAddress)({
+    programAddress,
+    seeds: [
+      (0, import_kit5.getUtf8Encoder)().encode("SubscriptionAuthority"),
+      (0, import_kit5.getAddressEncoder)().encode(seeds.user),
+      (0, import_kit5.getAddressEncoder)().encode(seeds.tokenMint)
+    ]
+  });
+}
+
+// src/generated/pdas/subscriptionDelegation.ts
+var import_kit6 = require("@solana/kit");
+async function findSubscriptionDelegationPda(seeds, config = {}) {
+  const {
+    programAddress = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44"
+  } = config;
+  return await (0, import_kit6.getProgramDerivedAddress)({
+    programAddress,
+    seeds: [
+      (0, import_kit6.getUtf8Encoder)().encode("subscription"),
+      (0, import_kit6.getAddressEncoder)().encode(seeds.planPda),
+      (0, import_kit6.getAddressEncoder)().encode(seeds.subscriber)
+    ]
+  });
+}
+
+// src/generated/accounts/eventAuthority.ts
+function getEventAuthorityEncoder() {
+  return (0, import_kit7.getStructEncoder)([]);
+}
+function getEventAuthorityDecoder() {
+  return (0, import_kit7.getStructDecoder)([]);
+}
+function getEventAuthorityCodec() {
+  return (0, import_kit7.combineCodec)(getEventAuthorityEncoder(), getEventAuthorityDecoder());
+}
+function decodeEventAuthority(encodedAccount) {
+  return (0, import_kit7.decodeAccount)(encodedAccount, getEventAuthorityDecoder());
+}
+async function fetchEventAuthority(rpc, address, config) {
+  const maybeAccount = await fetchMaybeEventAuthority(rpc, address, config);
+  (0, import_kit7.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeEventAuthority(rpc, address, config) {
+  const maybeAccount = await (0, import_kit7.fetchEncodedAccount)(rpc, address, config);
+  return decodeEventAuthority(maybeAccount);
+}
+async function fetchAllEventAuthority(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeEventAuthority(rpc, addresses, config);
+  (0, import_kit7.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeEventAuthority(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit7.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeEventAuthority(maybeAccount));
+}
+async function fetchEventAuthorityFromSeeds(rpc, config = {}) {
+  const maybeAccount = await fetchMaybeEventAuthorityFromSeeds(rpc, config);
+  (0, import_kit7.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeEventAuthorityFromSeeds(rpc, config = {}) {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await findEventAuthorityPda({ programAddress });
+  return await fetchMaybeEventAuthority(rpc, address, fetchConfig);
+}
+
+// src/generated/accounts/fixedDelegation.ts
+var import_kit18 = require("@solana/kit");
+
+// src/generated/types/accountDiscriminator.ts
+var import_kit8 = require("@solana/kit");
+var AccountDiscriminator = /* @__PURE__ */ ((AccountDiscriminator2) => {
+  AccountDiscriminator2[AccountDiscriminator2["SubscriptionAuthority"] = 0] = "SubscriptionAuthority";
+  AccountDiscriminator2[AccountDiscriminator2["Plan"] = 1] = "Plan";
+  AccountDiscriminator2[AccountDiscriminator2["FixedDelegation"] = 2] = "FixedDelegation";
+  AccountDiscriminator2[AccountDiscriminator2["RecurringDelegation"] = 3] = "RecurringDelegation";
+  AccountDiscriminator2[AccountDiscriminator2["SubscriptionDelegation"] = 4] = "SubscriptionDelegation";
+  return AccountDiscriminator2;
+})(AccountDiscriminator || {});
+function getAccountDiscriminatorEncoder() {
+  return (0, import_kit8.getEnumEncoder)(AccountDiscriminator);
+}
+function getAccountDiscriminatorDecoder() {
+  return (0, import_kit8.getEnumDecoder)(AccountDiscriminator);
+}
+function getAccountDiscriminatorCodec() {
+  return (0, import_kit8.combineCodec)(getAccountDiscriminatorEncoder(), getAccountDiscriminatorDecoder());
+}
+
+// src/generated/types/createFixedDelegationData.ts
+var import_kit9 = require("@solana/kit");
+function getCreateFixedDelegationDataEncoder() {
+  return (0, import_kit9.getStructEncoder)([
+    ["nonce", (0, import_kit9.getU64Encoder)()],
+    ["amount", (0, import_kit9.getU64Encoder)()],
+    ["expiryTs", (0, import_kit9.getI64Encoder)()]
+  ]);
+}
+function getCreateFixedDelegationDataDecoder() {
+  return (0, import_kit9.getStructDecoder)([
+    ["nonce", (0, import_kit9.getU64Decoder)()],
+    ["amount", (0, import_kit9.getU64Decoder)()],
+    ["expiryTs", (0, import_kit9.getI64Decoder)()]
+  ]);
+}
+function getCreateFixedDelegationDataCodec() {
+  return (0, import_kit9.combineCodec)(getCreateFixedDelegationDataEncoder(), getCreateFixedDelegationDataDecoder());
+}
+
+// src/generated/types/createRecurringDelegationData.ts
+var import_kit10 = require("@solana/kit");
+function getCreateRecurringDelegationDataEncoder() {
+  return (0, import_kit10.getStructEncoder)([
+    ["nonce", (0, import_kit10.getU64Encoder)()],
+    ["amountPerPeriod", (0, import_kit10.getU64Encoder)()],
+    ["periodLengthS", (0, import_kit10.getU64Encoder)()],
+    ["startTs", (0, import_kit10.getI64Encoder)()],
+    ["expiryTs", (0, import_kit10.getI64Encoder)()]
+  ]);
+}
+function getCreateRecurringDelegationDataDecoder() {
+  return (0, import_kit10.getStructDecoder)([
+    ["nonce", (0, import_kit10.getU64Decoder)()],
+    ["amountPerPeriod", (0, import_kit10.getU64Decoder)()],
+    ["periodLengthS", (0, import_kit10.getU64Decoder)()],
+    ["startTs", (0, import_kit10.getI64Decoder)()],
+    ["expiryTs", (0, import_kit10.getI64Decoder)()]
+  ]);
+}
+function getCreateRecurringDelegationDataCodec() {
+  return (0, import_kit10.combineCodec)(getCreateRecurringDelegationDataEncoder(), getCreateRecurringDelegationDataDecoder());
+}
+
+// src/generated/types/header.ts
+var import_kit11 = require("@solana/kit");
+function getHeaderEncoder() {
+  return (0, import_kit11.getStructEncoder)([
+    ["discriminator", (0, import_kit11.getU8Encoder)()],
+    ["version", (0, import_kit11.getU8Encoder)()],
+    ["bump", (0, import_kit11.getU8Encoder)()],
+    ["delegator", (0, import_kit11.getAddressEncoder)()],
+    ["delegatee", (0, import_kit11.getAddressEncoder)()],
+    ["payer", (0, import_kit11.getAddressEncoder)()],
+    ["initId", (0, import_kit11.getI64Encoder)()]
+  ]);
+}
+function getHeaderDecoder() {
+  return (0, import_kit11.getStructDecoder)([
+    ["discriminator", (0, import_kit11.getU8Decoder)()],
+    ["version", (0, import_kit11.getU8Decoder)()],
+    ["bump", (0, import_kit11.getU8Decoder)()],
+    ["delegator", (0, import_kit11.getAddressDecoder)()],
+    ["delegatee", (0, import_kit11.getAddressDecoder)()],
+    ["payer", (0, import_kit11.getAddressDecoder)()],
+    ["initId", (0, import_kit11.getI64Decoder)()]
+  ]);
+}
+function getHeaderCodec() {
+  return (0, import_kit11.combineCodec)(getHeaderEncoder(), getHeaderDecoder());
+}
+
+// src/generated/types/planData.ts
+var import_kit12 = require("@solana/kit");
+function getPlanDataEncoder() {
+  return (0, import_kit12.getStructEncoder)([
+    ["planId", (0, import_kit12.getU64Encoder)()],
+    ["mint", (0, import_kit12.getAddressEncoder)()],
+    ["terms", getPlanTermsEncoder()],
+    ["endTs", (0, import_kit12.getI64Encoder)()],
+    ["destinations", (0, import_kit12.getArrayEncoder)((0, import_kit12.getAddressEncoder)(), { size: 4 })],
+    ["pullers", (0, import_kit12.getArrayEncoder)((0, import_kit12.getAddressEncoder)(), { size: 4 })],
+    ["metadataUri", (0, import_kit12.fixEncoderSize)((0, import_kit12.getUtf8Encoder)(), 128)]
+  ]);
+}
+function getPlanDataDecoder() {
+  return (0, import_kit12.getStructDecoder)([
+    ["planId", (0, import_kit12.getU64Decoder)()],
+    ["mint", (0, import_kit12.getAddressDecoder)()],
+    ["terms", getPlanTermsDecoder()],
+    ["endTs", (0, import_kit12.getI64Decoder)()],
+    ["destinations", (0, import_kit12.getArrayDecoder)((0, import_kit12.getAddressDecoder)(), { size: 4 })],
+    ["pullers", (0, import_kit12.getArrayDecoder)((0, import_kit12.getAddressDecoder)(), { size: 4 })],
+    ["metadataUri", (0, import_kit12.fixDecoderSize)((0, import_kit12.getUtf8Decoder)(), 128)]
+  ]);
+}
+function getPlanDataCodec() {
+  return (0, import_kit12.combineCodec)(getPlanDataEncoder(), getPlanDataDecoder());
+}
+
+// src/generated/types/planStatus.ts
+var import_kit13 = require("@solana/kit");
+var PlanStatus = /* @__PURE__ */ ((PlanStatus2) => {
+  PlanStatus2[PlanStatus2["Sunset"] = 0] = "Sunset";
+  PlanStatus2[PlanStatus2["Active"] = 1] = "Active";
+  return PlanStatus2;
+})(PlanStatus || {});
+function getPlanStatusEncoder() {
+  return (0, import_kit13.getEnumEncoder)(PlanStatus);
+}
+function getPlanStatusDecoder() {
+  return (0, import_kit13.getEnumDecoder)(PlanStatus);
+}
+function getPlanStatusCodec() {
+  return (0, import_kit13.combineCodec)(getPlanStatusEncoder(), getPlanStatusDecoder());
+}
+
+// src/generated/types/planTerms.ts
+var import_kit14 = require("@solana/kit");
+function getPlanTermsEncoder() {
+  return (0, import_kit14.getStructEncoder)([
+    ["amount", (0, import_kit14.getU64Encoder)()],
+    ["periodHours", (0, import_kit14.getU64Encoder)()],
+    ["createdAt", (0, import_kit14.getI64Encoder)()]
+  ]);
+}
+function getPlanTermsDecoder() {
+  return (0, import_kit14.getStructDecoder)([
+    ["amount", (0, import_kit14.getU64Decoder)()],
+    ["periodHours", (0, import_kit14.getU64Decoder)()],
+    ["createdAt", (0, import_kit14.getI64Decoder)()]
+  ]);
+}
+function getPlanTermsCodec() {
+  return (0, import_kit14.combineCodec)(getPlanTermsEncoder(), getPlanTermsDecoder());
+}
+
+// src/generated/types/subscribeData.ts
+var import_kit15 = require("@solana/kit");
+function getSubscribeDataEncoder() {
+  return (0, import_kit15.getStructEncoder)([
+    ["planId", (0, import_kit15.getU64Encoder)()],
+    ["planBump", (0, import_kit15.getU8Encoder)()],
+    ["expectedMint", (0, import_kit15.getAddressEncoder)()],
+    ["expectedAmount", (0, import_kit15.getU64Encoder)()],
+    ["expectedPeriodHours", (0, import_kit15.getU64Encoder)()],
+    ["expectedCreatedAt", (0, import_kit15.getI64Encoder)()]
+  ]);
+}
+function getSubscribeDataDecoder() {
+  return (0, import_kit15.getStructDecoder)([
+    ["planId", (0, import_kit15.getU64Decoder)()],
+    ["planBump", (0, import_kit15.getU8Decoder)()],
+    ["expectedMint", (0, import_kit15.getAddressDecoder)()],
+    ["expectedAmount", (0, import_kit15.getU64Decoder)()],
+    ["expectedPeriodHours", (0, import_kit15.getU64Decoder)()],
+    ["expectedCreatedAt", (0, import_kit15.getI64Decoder)()]
+  ]);
+}
+function getSubscribeDataCodec() {
+  return (0, import_kit15.combineCodec)(getSubscribeDataEncoder(), getSubscribeDataDecoder());
+}
+
+// src/generated/types/transferData.ts
+var import_kit16 = require("@solana/kit");
+function getTransferDataEncoder() {
+  return (0, import_kit16.getStructEncoder)([
+    ["amount", (0, import_kit16.getU64Encoder)()],
+    ["delegator", (0, import_kit16.getAddressEncoder)()],
+    ["mint", (0, import_kit16.getAddressEncoder)()]
+  ]);
+}
+function getTransferDataDecoder() {
+  return (0, import_kit16.getStructDecoder)([
+    ["amount", (0, import_kit16.getU64Decoder)()],
+    ["delegator", (0, import_kit16.getAddressDecoder)()],
+    ["mint", (0, import_kit16.getAddressDecoder)()]
+  ]);
+}
+function getTransferDataCodec() {
+  return (0, import_kit16.combineCodec)(getTransferDataEncoder(), getTransferDataDecoder());
+}
+
+// src/generated/types/updatePlanData.ts
+var import_kit17 = require("@solana/kit");
+function getUpdatePlanDataEncoder() {
+  return (0, import_kit17.getStructEncoder)([
+    ["status", (0, import_kit17.getU8Encoder)()],
+    ["endTs", (0, import_kit17.getI64Encoder)()],
+    ["pullers", (0, import_kit17.getArrayEncoder)((0, import_kit17.getAddressEncoder)(), { size: 4 })],
+    ["metadataUri", (0, import_kit17.fixEncoderSize)((0, import_kit17.getUtf8Encoder)(), 128)]
+  ]);
+}
+function getUpdatePlanDataDecoder() {
+  return (0, import_kit17.getStructDecoder)([
+    ["status", (0, import_kit17.getU8Decoder)()],
+    ["endTs", (0, import_kit17.getI64Decoder)()],
+    ["pullers", (0, import_kit17.getArrayDecoder)((0, import_kit17.getAddressDecoder)(), { size: 4 })],
+    ["metadataUri", (0, import_kit17.fixDecoderSize)((0, import_kit17.getUtf8Decoder)(), 128)]
+  ]);
+}
+function getUpdatePlanDataCodec() {
+  return (0, import_kit17.combineCodec)(getUpdatePlanDataEncoder(), getUpdatePlanDataDecoder());
+}
+
+// src/generated/accounts/fixedDelegation.ts
+function getFixedDelegationEncoder() {
+  return (0, import_kit18.getStructEncoder)([
+    ["header", getHeaderEncoder()],
+    ["subscriptionAuthority", (0, import_kit18.getAddressEncoder)()],
+    ["mint", (0, import_kit18.getAddressEncoder)()],
+    ["amount", (0, import_kit18.getU64Encoder)()],
+    ["expiryTs", (0, import_kit18.getI64Encoder)()]
+  ]);
+}
+function getFixedDelegationDecoder() {
+  return (0, import_kit18.getStructDecoder)([
+    ["header", getHeaderDecoder()],
+    ["subscriptionAuthority", (0, import_kit18.getAddressDecoder)()],
+    ["mint", (0, import_kit18.getAddressDecoder)()],
+    ["amount", (0, import_kit18.getU64Decoder)()],
+    ["expiryTs", (0, import_kit18.getI64Decoder)()]
+  ]);
+}
+function getFixedDelegationCodec() {
+  return (0, import_kit18.combineCodec)(getFixedDelegationEncoder(), getFixedDelegationDecoder());
+}
+function decodeFixedDelegation(encodedAccount) {
+  return (0, import_kit18.decodeAccount)(encodedAccount, getFixedDelegationDecoder());
+}
+async function fetchFixedDelegation(rpc, address, config) {
+  const maybeAccount = await fetchMaybeFixedDelegation(rpc, address, config);
+  (0, import_kit18.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeFixedDelegation(rpc, address, config) {
+  const maybeAccount = await (0, import_kit18.fetchEncodedAccount)(rpc, address, config);
+  return decodeFixedDelegation(maybeAccount);
+}
+async function fetchAllFixedDelegation(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeFixedDelegation(rpc, addresses, config);
+  (0, import_kit18.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeFixedDelegation(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit18.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeFixedDelegation(maybeAccount));
+}
+async function fetchFixedDelegationFromSeeds(rpc, seeds, config = {}) {
+  const maybeAccount = await fetchMaybeFixedDelegationFromSeeds(rpc, seeds, config);
+  (0, import_kit18.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeFixedDelegationFromSeeds(rpc, seeds, config = {}) {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await findFixedDelegationPda(seeds, { programAddress });
+  return await fetchMaybeFixedDelegation(rpc, address, fetchConfig);
+}
+
+// src/generated/accounts/plan.ts
+var import_kit19 = require("@solana/kit");
+function getPlanEncoder() {
+  return (0, import_kit19.getStructEncoder)([
+    ["discriminator", (0, import_kit19.getU8Encoder)()],
+    ["owner", (0, import_kit19.getAddressEncoder)()],
+    ["bump", (0, import_kit19.getU8Encoder)()],
+    ["status", (0, import_kit19.getU8Encoder)()],
+    ["data", getPlanDataEncoder()]
+  ]);
+}
+function getPlanDecoder() {
+  return (0, import_kit19.getStructDecoder)([
+    ["discriminator", (0, import_kit19.getU8Decoder)()],
+    ["owner", (0, import_kit19.getAddressDecoder)()],
+    ["bump", (0, import_kit19.getU8Decoder)()],
+    ["status", (0, import_kit19.getU8Decoder)()],
+    ["data", getPlanDataDecoder()]
+  ]);
+}
+function getPlanCodec() {
+  return (0, import_kit19.combineCodec)(getPlanEncoder(), getPlanDecoder());
+}
+function decodePlan(encodedAccount) {
+  return (0, import_kit19.decodeAccount)(encodedAccount, getPlanDecoder());
+}
+async function fetchPlan(rpc, address, config) {
+  const maybeAccount = await fetchMaybePlan(rpc, address, config);
+  (0, import_kit19.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybePlan(rpc, address, config) {
+  const maybeAccount = await (0, import_kit19.fetchEncodedAccount)(rpc, address, config);
+  return decodePlan(maybeAccount);
+}
+async function fetchAllPlan(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybePlan(rpc, addresses, config);
+  (0, import_kit19.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybePlan(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit19.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodePlan(maybeAccount));
+}
+async function fetchPlanFromSeeds(rpc, seeds, config = {}) {
+  const maybeAccount = await fetchMaybePlanFromSeeds(rpc, seeds, config);
+  (0, import_kit19.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybePlanFromSeeds(rpc, seeds, config = {}) {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await findPlanPda(seeds, { programAddress });
+  return await fetchMaybePlan(rpc, address, fetchConfig);
+}
+
+// src/generated/accounts/recurringDelegation.ts
+var import_kit20 = require("@solana/kit");
+function getRecurringDelegationEncoder() {
+  return (0, import_kit20.getStructEncoder)([
+    ["header", getHeaderEncoder()],
+    ["subscriptionAuthority", (0, import_kit20.getAddressEncoder)()],
+    ["mint", (0, import_kit20.getAddressEncoder)()],
+    ["currentPeriodStartTs", (0, import_kit20.getI64Encoder)()],
+    ["periodLengthS", (0, import_kit20.getU64Encoder)()],
+    ["expiryTs", (0, import_kit20.getI64Encoder)()],
+    ["amountPerPeriod", (0, import_kit20.getU64Encoder)()],
+    ["amountPulledInPeriod", (0, import_kit20.getU64Encoder)()]
+  ]);
+}
+function getRecurringDelegationDecoder() {
+  return (0, import_kit20.getStructDecoder)([
+    ["header", getHeaderDecoder()],
+    ["subscriptionAuthority", (0, import_kit20.getAddressDecoder)()],
+    ["mint", (0, import_kit20.getAddressDecoder)()],
+    ["currentPeriodStartTs", (0, import_kit20.getI64Decoder)()],
+    ["periodLengthS", (0, import_kit20.getU64Decoder)()],
+    ["expiryTs", (0, import_kit20.getI64Decoder)()],
+    ["amountPerPeriod", (0, import_kit20.getU64Decoder)()],
+    ["amountPulledInPeriod", (0, import_kit20.getU64Decoder)()]
+  ]);
+}
+function getRecurringDelegationCodec() {
+  return (0, import_kit20.combineCodec)(getRecurringDelegationEncoder(), getRecurringDelegationDecoder());
+}
+function decodeRecurringDelegation(encodedAccount) {
+  return (0, import_kit20.decodeAccount)(encodedAccount, getRecurringDelegationDecoder());
+}
+async function fetchRecurringDelegation(rpc, address, config) {
+  const maybeAccount = await fetchMaybeRecurringDelegation(rpc, address, config);
+  (0, import_kit20.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeRecurringDelegation(rpc, address, config) {
+  const maybeAccount = await (0, import_kit20.fetchEncodedAccount)(rpc, address, config);
+  return decodeRecurringDelegation(maybeAccount);
+}
+async function fetchAllRecurringDelegation(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeRecurringDelegation(rpc, addresses, config);
+  (0, import_kit20.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeRecurringDelegation(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit20.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeRecurringDelegation(maybeAccount));
+}
+async function fetchRecurringDelegationFromSeeds(rpc, seeds, config = {}) {
+  const maybeAccount = await fetchMaybeRecurringDelegationFromSeeds(rpc, seeds, config);
+  (0, import_kit20.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeRecurringDelegationFromSeeds(rpc, seeds, config = {}) {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await findRecurringDelegationPda(seeds, { programAddress });
+  return await fetchMaybeRecurringDelegation(rpc, address, fetchConfig);
+}
+
+// src/generated/accounts/subscriptionAuthority.ts
+var import_kit21 = require("@solana/kit");
+function getSubscriptionAuthorityEncoder() {
+  return (0, import_kit21.getStructEncoder)([
+    ["discriminator", (0, import_kit21.getU8Encoder)()],
+    ["user", (0, import_kit21.getAddressEncoder)()],
+    ["tokenMint", (0, import_kit21.getAddressEncoder)()],
+    ["payer", (0, import_kit21.getAddressEncoder)()],
+    ["bump", (0, import_kit21.getU8Encoder)()],
+    ["initId", (0, import_kit21.getI64Encoder)()]
+  ]);
+}
+function getSubscriptionAuthorityDecoder() {
+  return (0, import_kit21.getStructDecoder)([
+    ["discriminator", (0, import_kit21.getU8Decoder)()],
+    ["user", (0, import_kit21.getAddressDecoder)()],
+    ["tokenMint", (0, import_kit21.getAddressDecoder)()],
+    ["payer", (0, import_kit21.getAddressDecoder)()],
+    ["bump", (0, import_kit21.getU8Decoder)()],
+    ["initId", (0, import_kit21.getI64Decoder)()]
+  ]);
+}
+function getSubscriptionAuthorityCodec() {
+  return (0, import_kit21.combineCodec)(getSubscriptionAuthorityEncoder(), getSubscriptionAuthorityDecoder());
+}
+function decodeSubscriptionAuthority(encodedAccount) {
+  return (0, import_kit21.decodeAccount)(encodedAccount, getSubscriptionAuthorityDecoder());
+}
+async function fetchSubscriptionAuthority(rpc, address, config) {
+  const maybeAccount = await fetchMaybeSubscriptionAuthority(rpc, address, config);
+  (0, import_kit21.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeSubscriptionAuthority(rpc, address, config) {
+  const maybeAccount = await (0, import_kit21.fetchEncodedAccount)(rpc, address, config);
+  return decodeSubscriptionAuthority(maybeAccount);
+}
+async function fetchAllSubscriptionAuthority(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeSubscriptionAuthority(rpc, addresses, config);
+  (0, import_kit21.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeSubscriptionAuthority(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit21.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeSubscriptionAuthority(maybeAccount));
+}
+async function fetchSubscriptionAuthorityFromSeeds(rpc, seeds, config = {}) {
+  const maybeAccount = await fetchMaybeSubscriptionAuthorityFromSeeds(rpc, seeds, config);
+  (0, import_kit21.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeSubscriptionAuthorityFromSeeds(rpc, seeds, config = {}) {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await findSubscriptionAuthorityPda(seeds, { programAddress });
+  return await fetchMaybeSubscriptionAuthority(rpc, address, fetchConfig);
+}
+
+// src/generated/accounts/subscriptionDelegation.ts
+var import_kit22 = require("@solana/kit");
+function getSubscriptionDelegationEncoder() {
+  return (0, import_kit22.getStructEncoder)([
+    ["header", getHeaderEncoder()],
+    ["terms", getPlanTermsEncoder()],
+    ["amountPulledInPeriod", (0, import_kit22.getU64Encoder)()],
+    ["currentPeriodStartTs", (0, import_kit22.getI64Encoder)()],
+    ["expiresAtTs", (0, import_kit22.getI64Encoder)()]
+  ]);
+}
+function getSubscriptionDelegationDecoder() {
+  return (0, import_kit22.getStructDecoder)([
+    ["header", getHeaderDecoder()],
+    ["terms", getPlanTermsDecoder()],
+    ["amountPulledInPeriod", (0, import_kit22.getU64Decoder)()],
+    ["currentPeriodStartTs", (0, import_kit22.getI64Decoder)()],
+    ["expiresAtTs", (0, import_kit22.getI64Decoder)()]
+  ]);
+}
+function getSubscriptionDelegationCodec() {
+  return (0, import_kit22.combineCodec)(getSubscriptionDelegationEncoder(), getSubscriptionDelegationDecoder());
+}
+function decodeSubscriptionDelegation(encodedAccount) {
+  return (0, import_kit22.decodeAccount)(encodedAccount, getSubscriptionDelegationDecoder());
+}
+async function fetchSubscriptionDelegation(rpc, address, config) {
+  const maybeAccount = await fetchMaybeSubscriptionDelegation(rpc, address, config);
+  (0, import_kit22.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeSubscriptionDelegation(rpc, address, config) {
+  const maybeAccount = await (0, import_kit22.fetchEncodedAccount)(rpc, address, config);
+  return decodeSubscriptionDelegation(maybeAccount);
+}
+async function fetchAllSubscriptionDelegation(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeSubscriptionDelegation(rpc, addresses, config);
+  (0, import_kit22.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeSubscriptionDelegation(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit22.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeSubscriptionDelegation(maybeAccount));
+}
+async function fetchSubscriptionDelegationFromSeeds(rpc, seeds, config = {}) {
+  const maybeAccount = await fetchMaybeSubscriptionDelegationFromSeeds(rpc, seeds, config);
+  (0, import_kit22.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeSubscriptionDelegationFromSeeds(rpc, seeds, config = {}) {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await findSubscriptionDelegationPda(seeds, { programAddress });
+  return await fetchMaybeSubscriptionDelegation(rpc, address, fetchConfig);
+}
+
+// src/generated/errors/subscriptions.ts
+var import_kit38 = require("@solana/kit");
+
+// src/generated/programs/subscriptions.ts
+var import_kit37 = require("@solana/kit");
+var import_program_client_core15 = require("@solana/program-client-core");
+
+// src/generated/instructions/cancelSubscription.ts
+var import_kit23 = require("@solana/kit");
+var import_program_client_core = require("@solana/program-client-core");
+var CANCEL_SUBSCRIPTION_DISCRIMINATOR = 12;
+function getCancelSubscriptionDiscriminatorBytes() {
+  return (0, import_kit23.getU8Encoder)().encode(CANCEL_SUBSCRIPTION_DISCRIMINATOR);
+}
+function getCancelSubscriptionInstructionDataEncoder() {
+  return (0, import_kit23.transformEncoder)((0, import_kit23.getStructEncoder)([["discriminator", (0, import_kit23.getU8Encoder)()]]), (value) => ({
+    ...value,
+    discriminator: CANCEL_SUBSCRIPTION_DISCRIMINATOR
+  }));
+}
+function getCancelSubscriptionInstructionDataDecoder() {
+  return (0, import_kit23.getStructDecoder)([["discriminator", (0, import_kit23.getU8Decoder)()]]);
+}
+function getCancelSubscriptionInstructionDataCodec() {
+  return (0, import_kit23.combineCodec)(getCancelSubscriptionInstructionDataEncoder(), getCancelSubscriptionInstructionDataDecoder());
+}
+async function getCancelSubscriptionInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    subscriber: { value: input.subscriber ?? null, isWritable: false },
+    planPda: { value: input.planPda ?? null, isWritable: false },
+    subscriptionPda: { value: input.subscriptionPda ?? null, isWritable: true },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.subscriptionPda.value) {
+    accounts.subscriptionPda.value = await findSubscriptionDelegationPda({
+      planPda: (0, import_program_client_core.getAddressFromResolvedInstructionAccount)("planPda", accounts.planPda.value),
+      subscriber: (0, import_program_client_core.getAddressFromResolvedInstructionAccount)("subscriber", accounts.subscriber.value)
+    });
+  }
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = (0, import_program_client_core.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("subscriber", accounts.subscriber),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("subscriptionPda", accounts.subscriptionPda),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getCancelSubscriptionInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function getCancelSubscriptionInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    subscriber: { value: input.subscriber ?? null, isWritable: false },
+    planPda: { value: input.planPda ?? null, isWritable: false },
+    subscriptionPda: { value: input.subscriptionPda ?? null, isWritable: true },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = (0, import_program_client_core.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("subscriber", accounts.subscriber),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("subscriptionPda", accounts.subscriptionPda),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getCancelSubscriptionInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseCancelSubscriptionInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new import_kit23.SolanaError(import_kit23.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 5
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      subscriber: getNextAccount(),
+      planPda: getNextAccount(),
+      subscriptionPda: getNextAccount(),
+      eventAuthority: getNextAccount(),
+      selfProgram: getNextAccount()
+    },
+    data: getCancelSubscriptionInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/closeSubscriptionAuthority.ts
+var import_kit24 = require("@solana/kit");
+var import_program_client_core2 = require("@solana/program-client-core");
+var CLOSE_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR = 6;
+function getCloseSubscriptionAuthorityDiscriminatorBytes() {
+  return (0, import_kit24.getU8Encoder)().encode(CLOSE_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR);
+}
+function getCloseSubscriptionAuthorityInstructionDataEncoder() {
+  return (0, import_kit24.transformEncoder)((0, import_kit24.getStructEncoder)([["discriminator", (0, import_kit24.getU8Encoder)()]]), (value) => ({
+    ...value,
+    discriminator: CLOSE_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR
+  }));
+}
+function getCloseSubscriptionAuthorityInstructionDataDecoder() {
+  return (0, import_kit24.getStructDecoder)([["discriminator", (0, import_kit24.getU8Decoder)()]]);
+}
+function getCloseSubscriptionAuthorityInstructionDataCodec() {
+  return (0, import_kit24.combineCodec)(
+    getCloseSubscriptionAuthorityInstructionDataEncoder(),
+    getCloseSubscriptionAuthorityInstructionDataDecoder()
+  );
+}
+function getCloseSubscriptionAuthorityInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    user: { value: input.user ?? null, isWritable: true },
+    subscriptionAuthority: { value: input.subscriptionAuthority ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = (0, import_program_client_core2.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("user", accounts.user),
+      getAccountMeta("subscriptionAuthority", accounts.subscriptionAuthority)
+    ],
+    data: getCloseSubscriptionAuthorityInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseCloseSubscriptionAuthorityInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new import_kit24.SolanaError(import_kit24.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { user: getNextAccount(), subscriptionAuthority: getNextAccount() },
+    data: getCloseSubscriptionAuthorityInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/createFixedDelegation.ts
+var import_kit25 = require("@solana/kit");
+var import_program_client_core3 = require("@solana/program-client-core");
+var CREATE_FIXED_DELEGATION_DISCRIMINATOR = 1;
+function getCreateFixedDelegationDiscriminatorBytes() {
+  return (0, import_kit25.getU8Encoder)().encode(CREATE_FIXED_DELEGATION_DISCRIMINATOR);
+}
+function getCreateFixedDelegationInstructionDataEncoder() {
+  return (0, import_kit25.transformEncoder)(
+    (0, import_kit25.getStructEncoder)([
+      ["discriminator", (0, import_kit25.getU8Encoder)()],
+      ["fixedDelegation", getCreateFixedDelegationDataEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: CREATE_FIXED_DELEGATION_DISCRIMINATOR })
+  );
+}
+function getCreateFixedDelegationInstructionDataDecoder() {
+  return (0, import_kit25.getStructDecoder)([
+    ["discriminator", (0, import_kit25.getU8Decoder)()],
+    ["fixedDelegation", getCreateFixedDelegationDataDecoder()]
+  ]);
+}
+function getCreateFixedDelegationInstructionDataCodec() {
+  return (0, import_kit25.combineCodec)(
+    getCreateFixedDelegationInstructionDataEncoder(),
+    getCreateFixedDelegationInstructionDataDecoder()
+  );
+}
+function getCreateFixedDelegationInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    delegator: { value: input.delegator ?? null, isWritable: true },
+    subscriptionAuthority: { value: input.subscriptionAuthority ?? null, isWritable: false },
+    delegationAccount: { value: input.delegationAccount ?? null, isWritable: true },
+    delegatee: { value: input.delegatee ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = (0, import_program_client_core3.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("delegator", accounts.delegator),
+      getAccountMeta("subscriptionAuthority", accounts.subscriptionAuthority),
+      getAccountMeta("delegationAccount", accounts.delegationAccount),
+      getAccountMeta("delegatee", accounts.delegatee),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getCreateFixedDelegationInstructionDataEncoder().encode(args),
+    programAddress
+  });
+}
+function parseCreateFixedDelegationInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new import_kit25.SolanaError(import_kit25.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 5
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      delegator: getNextAccount(),
+      subscriptionAuthority: getNextAccount(),
+      delegationAccount: getNextAccount(),
+      delegatee: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getCreateFixedDelegationInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/createPlan.ts
+var import_kit26 = require("@solana/kit");
+var import_program_client_core4 = require("@solana/program-client-core");
+var CREATE_PLAN_DISCRIMINATOR = 7;
+function getCreatePlanDiscriminatorBytes() {
+  return (0, import_kit26.getU8Encoder)().encode(CREATE_PLAN_DISCRIMINATOR);
+}
+function getCreatePlanInstructionDataEncoder() {
+  return (0, import_kit26.transformEncoder)(
+    (0, import_kit26.getStructEncoder)([
+      ["discriminator", (0, import_kit26.getU8Encoder)()],
+      ["planData", getPlanDataEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: CREATE_PLAN_DISCRIMINATOR })
+  );
+}
+function getCreatePlanInstructionDataDecoder() {
+  return (0, import_kit26.getStructDecoder)([
+    ["discriminator", (0, import_kit26.getU8Decoder)()],
+    ["planData", getPlanDataDecoder()]
+  ]);
+}
+function getCreatePlanInstructionDataCodec() {
+  return (0, import_kit26.combineCodec)(getCreatePlanInstructionDataEncoder(), getCreatePlanInstructionDataDecoder());
+}
+function getCreatePlanInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    merchant: { value: input.merchant ?? null, isWritable: true },
+    planPda: { value: input.planPda ?? null, isWritable: true },
+    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  const getAccountMeta = (0, import_program_client_core4.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("merchant", accounts.merchant),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("tokenMint", accounts.tokenMint),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("tokenProgram", accounts.tokenProgram)
+    ],
+    data: getCreatePlanInstructionDataEncoder().encode(args),
+    programAddress
+  });
+}
+function parseCreatePlanInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new import_kit26.SolanaError(import_kit26.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 5
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      merchant: getNextAccount(),
+      planPda: getNextAccount(),
+      tokenMint: getNextAccount(),
+      systemProgram: getNextAccount(),
+      tokenProgram: getNextAccount()
+    },
+    data: getCreatePlanInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/createRecurringDelegation.ts
+var import_kit27 = require("@solana/kit");
+var import_program_client_core5 = require("@solana/program-client-core");
+var CREATE_RECURRING_DELEGATION_DISCRIMINATOR = 2;
+function getCreateRecurringDelegationDiscriminatorBytes() {
+  return (0, import_kit27.getU8Encoder)().encode(CREATE_RECURRING_DELEGATION_DISCRIMINATOR);
+}
+function getCreateRecurringDelegationInstructionDataEncoder() {
+  return (0, import_kit27.transformEncoder)(
+    (0, import_kit27.getStructEncoder)([
+      ["discriminator", (0, import_kit27.getU8Encoder)()],
+      ["recurringDelegation", getCreateRecurringDelegationDataEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: CREATE_RECURRING_DELEGATION_DISCRIMINATOR })
+  );
+}
+function getCreateRecurringDelegationInstructionDataDecoder() {
+  return (0, import_kit27.getStructDecoder)([
+    ["discriminator", (0, import_kit27.getU8Decoder)()],
+    ["recurringDelegation", getCreateRecurringDelegationDataDecoder()]
+  ]);
+}
+function getCreateRecurringDelegationInstructionDataCodec() {
+  return (0, import_kit27.combineCodec)(
+    getCreateRecurringDelegationInstructionDataEncoder(),
+    getCreateRecurringDelegationInstructionDataDecoder()
+  );
+}
+function getCreateRecurringDelegationInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    delegator: { value: input.delegator ?? null, isWritable: true },
+    subscriptionAuthority: { value: input.subscriptionAuthority ?? null, isWritable: false },
+    delegationAccount: { value: input.delegationAccount ?? null, isWritable: true },
+    delegatee: { value: input.delegatee ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = (0, import_program_client_core5.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("delegator", accounts.delegator),
+      getAccountMeta("subscriptionAuthority", accounts.subscriptionAuthority),
+      getAccountMeta("delegationAccount", accounts.delegationAccount),
+      getAccountMeta("delegatee", accounts.delegatee),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getCreateRecurringDelegationInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseCreateRecurringDelegationInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new import_kit27.SolanaError(import_kit27.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 5
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      delegator: getNextAccount(),
+      subscriptionAuthority: getNextAccount(),
+      delegationAccount: getNextAccount(),
+      delegatee: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getCreateRecurringDelegationInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/deletePlan.ts
+var import_kit28 = require("@solana/kit");
+var import_program_client_core6 = require("@solana/program-client-core");
+var DELETE_PLAN_DISCRIMINATOR = 9;
+function getDeletePlanDiscriminatorBytes() {
+  return (0, import_kit28.getU8Encoder)().encode(DELETE_PLAN_DISCRIMINATOR);
+}
+function getDeletePlanInstructionDataEncoder() {
+  return (0, import_kit28.transformEncoder)((0, import_kit28.getStructEncoder)([["discriminator", (0, import_kit28.getU8Encoder)()]]), (value) => ({
+    ...value,
+    discriminator: DELETE_PLAN_DISCRIMINATOR
+  }));
+}
+function getDeletePlanInstructionDataDecoder() {
+  return (0, import_kit28.getStructDecoder)([["discriminator", (0, import_kit28.getU8Decoder)()]]);
+}
+function getDeletePlanInstructionDataCodec() {
+  return (0, import_kit28.combineCodec)(getDeletePlanInstructionDataEncoder(), getDeletePlanInstructionDataDecoder());
+}
+function getDeletePlanInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    owner: { value: input.owner ?? null, isWritable: true },
+    planPda: { value: input.planPda ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = (0, import_program_client_core6.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [getAccountMeta("owner", accounts.owner), getAccountMeta("planPda", accounts.planPda)],
+    data: getDeletePlanInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseDeletePlanInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new import_kit28.SolanaError(import_kit28.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { owner: getNextAccount(), planPda: getNextAccount() },
+    data: getDeletePlanInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/initSubscriptionAuthority.ts
+var import_kit29 = require("@solana/kit");
+var import_program_client_core7 = require("@solana/program-client-core");
+var INIT_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR = 0;
+function getInitSubscriptionAuthorityDiscriminatorBytes() {
+  return (0, import_kit29.getU8Encoder)().encode(INIT_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR);
+}
+function getInitSubscriptionAuthorityInstructionDataEncoder() {
+  return (0, import_kit29.transformEncoder)((0, import_kit29.getStructEncoder)([["discriminator", (0, import_kit29.getU8Encoder)()]]), (value) => ({
+    ...value,
+    discriminator: INIT_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR
+  }));
+}
+function getInitSubscriptionAuthorityInstructionDataDecoder() {
+  return (0, import_kit29.getStructDecoder)([["discriminator", (0, import_kit29.getU8Decoder)()]]);
+}
+function getInitSubscriptionAuthorityInstructionDataCodec() {
+  return (0, import_kit29.combineCodec)(
+    getInitSubscriptionAuthorityInstructionDataEncoder(),
+    getInitSubscriptionAuthorityInstructionDataDecoder()
+  );
+}
+async function getInitSubscriptionAuthorityInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    owner: { value: input.owner ?? null, isWritable: true },
+    subscriptionAuthority: { value: input.subscriptionAuthority ?? null, isWritable: true },
+    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
+    userAta: { value: input.userAta ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.subscriptionAuthority.value) {
+    accounts.subscriptionAuthority.value = await findSubscriptionAuthorityPda({
+      user: (0, import_program_client_core7.getAddressFromResolvedInstructionAccount)("owner", accounts.owner.value),
+      tokenMint: (0, import_program_client_core7.getAddressFromResolvedInstructionAccount)("tokenMint", accounts.tokenMint.value)
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = (0, import_program_client_core7.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("subscriptionAuthority", accounts.subscriptionAuthority),
+      getAccountMeta("tokenMint", accounts.tokenMint),
+      getAccountMeta("userAta", accounts.userAta),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("tokenProgram", accounts.tokenProgram)
+    ],
+    data: getInitSubscriptionAuthorityInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function getInitSubscriptionAuthorityInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    owner: { value: input.owner ?? null, isWritable: true },
+    subscriptionAuthority: { value: input.subscriptionAuthority ?? null, isWritable: true },
+    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
+    userAta: { value: input.userAta ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = (0, import_program_client_core7.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("subscriptionAuthority", accounts.subscriptionAuthority),
+      getAccountMeta("tokenMint", accounts.tokenMint),
+      getAccountMeta("userAta", accounts.userAta),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("tokenProgram", accounts.tokenProgram)
+    ],
+    data: getInitSubscriptionAuthorityInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseInitSubscriptionAuthorityInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    throw new import_kit29.SolanaError(import_kit29.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 6
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      owner: getNextAccount(),
+      subscriptionAuthority: getNextAccount(),
+      tokenMint: getNextAccount(),
+      userAta: getNextAccount(),
+      systemProgram: getNextAccount(),
+      tokenProgram: getNextAccount()
+    },
+    data: getInitSubscriptionAuthorityInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/resumeSubscription.ts
+var import_kit30 = require("@solana/kit");
+var import_program_client_core8 = require("@solana/program-client-core");
+var RESUME_SUBSCRIPTION_DISCRIMINATOR = 13;
+function getResumeSubscriptionDiscriminatorBytes() {
+  return (0, import_kit30.getU8Encoder)().encode(RESUME_SUBSCRIPTION_DISCRIMINATOR);
+}
+function getResumeSubscriptionInstructionDataEncoder() {
+  return (0, import_kit30.transformEncoder)((0, import_kit30.getStructEncoder)([["discriminator", (0, import_kit30.getU8Encoder)()]]), (value) => ({
+    ...value,
+    discriminator: RESUME_SUBSCRIPTION_DISCRIMINATOR
+  }));
+}
+function getResumeSubscriptionInstructionDataDecoder() {
+  return (0, import_kit30.getStructDecoder)([["discriminator", (0, import_kit30.getU8Decoder)()]]);
+}
+function getResumeSubscriptionInstructionDataCodec() {
+  return (0, import_kit30.combineCodec)(getResumeSubscriptionInstructionDataEncoder(), getResumeSubscriptionInstructionDataDecoder());
+}
+async function getResumeSubscriptionInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    subscriber: { value: input.subscriber ?? null, isWritable: false },
+    planPda: { value: input.planPda ?? null, isWritable: false },
+    subscriptionPda: { value: input.subscriptionPda ?? null, isWritable: true },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.subscriptionPda.value) {
+    accounts.subscriptionPda.value = await findSubscriptionDelegationPda({
+      planPda: (0, import_program_client_core8.getAddressFromResolvedInstructionAccount)("planPda", accounts.planPda.value),
+      subscriber: (0, import_program_client_core8.getAddressFromResolvedInstructionAccount)("subscriber", accounts.subscriber.value)
+    });
+  }
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = (0, import_program_client_core8.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("subscriber", accounts.subscriber),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("subscriptionPda", accounts.subscriptionPda),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getResumeSubscriptionInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function getResumeSubscriptionInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    subscriber: { value: input.subscriber ?? null, isWritable: false },
+    planPda: { value: input.planPda ?? null, isWritable: false },
+    subscriptionPda: { value: input.subscriptionPda ?? null, isWritable: true },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = (0, import_program_client_core8.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("subscriber", accounts.subscriber),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("subscriptionPda", accounts.subscriptionPda),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getResumeSubscriptionInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseResumeSubscriptionInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new import_kit30.SolanaError(import_kit30.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 5
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      subscriber: getNextAccount(),
+      planPda: getNextAccount(),
+      subscriptionPda: getNextAccount(),
+      eventAuthority: getNextAccount(),
+      selfProgram: getNextAccount()
+    },
+    data: getResumeSubscriptionInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/revokeDelegation.ts
+var import_kit31 = require("@solana/kit");
+var import_program_client_core9 = require("@solana/program-client-core");
+var REVOKE_DELEGATION_DISCRIMINATOR = 3;
+function getRevokeDelegationDiscriminatorBytes() {
+  return (0, import_kit31.getU8Encoder)().encode(REVOKE_DELEGATION_DISCRIMINATOR);
+}
+function getRevokeDelegationInstructionDataEncoder() {
+  return (0, import_kit31.transformEncoder)((0, import_kit31.getStructEncoder)([["discriminator", (0, import_kit31.getU8Encoder)()]]), (value) => ({
+    ...value,
+    discriminator: REVOKE_DELEGATION_DISCRIMINATOR
+  }));
+}
+function getRevokeDelegationInstructionDataDecoder() {
+  return (0, import_kit31.getStructDecoder)([["discriminator", (0, import_kit31.getU8Decoder)()]]);
+}
+function getRevokeDelegationInstructionDataCodec() {
+  return (0, import_kit31.combineCodec)(getRevokeDelegationInstructionDataEncoder(), getRevokeDelegationInstructionDataDecoder());
+}
+function getRevokeDelegationInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: true },
+    delegationAccount: { value: input.delegationAccount ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = (0, import_program_client_core9.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("delegationAccount", accounts.delegationAccount)
+    ],
+    data: getRevokeDelegationInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseRevokeDelegationInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new import_kit31.SolanaError(import_kit31.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { authority: getNextAccount(), delegationAccount: getNextAccount() },
+    data: getRevokeDelegationInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/subscribe.ts
+var import_kit32 = require("@solana/kit");
+var import_program_client_core10 = require("@solana/program-client-core");
+var SUBSCRIBE_DISCRIMINATOR = 11;
+function getSubscribeDiscriminatorBytes() {
+  return (0, import_kit32.getU8Encoder)().encode(SUBSCRIBE_DISCRIMINATOR);
+}
+function getSubscribeInstructionDataEncoder() {
+  return (0, import_kit32.transformEncoder)(
+    (0, import_kit32.getStructEncoder)([
+      ["discriminator", (0, import_kit32.getU8Encoder)()],
+      ["subscribeData", getSubscribeDataEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: SUBSCRIBE_DISCRIMINATOR })
+  );
+}
+function getSubscribeInstructionDataDecoder() {
+  return (0, import_kit32.getStructDecoder)([
+    ["discriminator", (0, import_kit32.getU8Decoder)()],
+    ["subscribeData", getSubscribeDataDecoder()]
+  ]);
+}
+function getSubscribeInstructionDataCodec() {
+  return (0, import_kit32.combineCodec)(getSubscribeInstructionDataEncoder(), getSubscribeInstructionDataDecoder());
+}
+async function getSubscribeInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    subscriber: { value: input.subscriber ?? null, isWritable: true },
+    merchant: { value: input.merchant ?? null, isWritable: false },
+    planPda: { value: input.planPda ?? null, isWritable: false },
+    subscriptionPda: { value: input.subscriptionPda ?? null, isWritable: true },
+    subscriptionAuthorityPda: { value: input.subscriptionAuthorityPda ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.subscriptionPda.value) {
+    accounts.subscriptionPda.value = await findSubscriptionDelegationPda({
+      planPda: (0, import_program_client_core10.getAddressFromResolvedInstructionAccount)("planPda", accounts.planPda.value),
+      subscriber: (0, import_program_client_core10.getAddressFromResolvedInstructionAccount)("subscriber", accounts.subscriber.value)
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = (0, import_program_client_core10.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("subscriber", accounts.subscriber),
+      getAccountMeta("merchant", accounts.merchant),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("subscriptionPda", accounts.subscriptionPda),
+      getAccountMeta("subscriptionAuthorityPda", accounts.subscriptionAuthorityPda),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getSubscribeInstructionDataEncoder().encode(args),
+    programAddress
+  });
+}
+function getSubscribeInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    subscriber: { value: input.subscriber ?? null, isWritable: true },
+    merchant: { value: input.merchant ?? null, isWritable: false },
+    planPda: { value: input.planPda ?? null, isWritable: false },
+    subscriptionPda: { value: input.subscriptionPda ?? null, isWritable: true },
+    subscriptionAuthorityPda: { value: input.subscriptionAuthorityPda ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = (0, import_program_client_core10.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("subscriber", accounts.subscriber),
+      getAccountMeta("merchant", accounts.merchant),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("subscriptionPda", accounts.subscriptionPda),
+      getAccountMeta("subscriptionAuthorityPda", accounts.subscriptionAuthorityPda),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getSubscribeInstructionDataEncoder().encode(args),
+    programAddress
+  });
+}
+function parseSubscribeInstruction(instruction) {
+  if (instruction.accounts.length < 8) {
+    throw new import_kit32.SolanaError(import_kit32.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 8
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      subscriber: getNextAccount(),
+      merchant: getNextAccount(),
+      planPda: getNextAccount(),
+      subscriptionPda: getNextAccount(),
+      subscriptionAuthorityPda: getNextAccount(),
+      systemProgram: getNextAccount(),
+      eventAuthority: getNextAccount(),
+      selfProgram: getNextAccount()
+    },
+    data: getSubscribeInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/transferFixed.ts
+var import_kit33 = require("@solana/kit");
+var import_program_client_core11 = require("@solana/program-client-core");
+var TRANSFER_FIXED_DISCRIMINATOR = 4;
+function getTransferFixedDiscriminatorBytes() {
+  return (0, import_kit33.getU8Encoder)().encode(TRANSFER_FIXED_DISCRIMINATOR);
+}
+function getTransferFixedInstructionDataEncoder() {
+  return (0, import_kit33.transformEncoder)(
+    (0, import_kit33.getStructEncoder)([
+      ["discriminator", (0, import_kit33.getU8Encoder)()],
+      ["transferData", getTransferDataEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: TRANSFER_FIXED_DISCRIMINATOR })
+  );
+}
+function getTransferFixedInstructionDataDecoder() {
+  return (0, import_kit33.getStructDecoder)([
+    ["discriminator", (0, import_kit33.getU8Decoder)()],
+    ["transferData", getTransferDataDecoder()]
+  ]);
+}
+function getTransferFixedInstructionDataCodec() {
+  return (0, import_kit33.combineCodec)(getTransferFixedInstructionDataEncoder(), getTransferFixedInstructionDataDecoder());
+}
+function getTransferFixedInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    delegationPda: { value: input.delegationPda ?? null, isWritable: true },
+    subscriptionAuthority: { value: input.subscriptionAuthority ?? null, isWritable: false },
+    delegatorAta: { value: input.delegatorAta ?? null, isWritable: true },
+    receiverAta: { value: input.receiverAta ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    delegatee: { value: input.delegatee ?? null, isWritable: false },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = (0, import_program_client_core11.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("delegationPda", accounts.delegationPda),
+      getAccountMeta("subscriptionAuthority", accounts.subscriptionAuthority),
+      getAccountMeta("delegatorAta", accounts.delegatorAta),
+      getAccountMeta("receiverAta", accounts.receiverAta),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+      getAccountMeta("delegatee", accounts.delegatee),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getTransferFixedInstructionDataEncoder().encode(args),
+    programAddress
+  });
+}
+function parseTransferFixedInstruction(instruction) {
+  if (instruction.accounts.length < 8) {
+    throw new import_kit33.SolanaError(import_kit33.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 8
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      delegationPda: getNextAccount(),
+      subscriptionAuthority: getNextAccount(),
+      delegatorAta: getNextAccount(),
+      receiverAta: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      delegatee: getNextAccount(),
+      eventAuthority: getNextAccount(),
+      selfProgram: getNextAccount()
+    },
+    data: getTransferFixedInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/transferRecurring.ts
+var import_kit34 = require("@solana/kit");
+var import_program_client_core12 = require("@solana/program-client-core");
+var TRANSFER_RECURRING_DISCRIMINATOR = 5;
+function getTransferRecurringDiscriminatorBytes() {
+  return (0, import_kit34.getU8Encoder)().encode(TRANSFER_RECURRING_DISCRIMINATOR);
+}
+function getTransferRecurringInstructionDataEncoder() {
+  return (0, import_kit34.transformEncoder)(
+    (0, import_kit34.getStructEncoder)([
+      ["discriminator", (0, import_kit34.getU8Encoder)()],
+      ["transferData", getTransferDataEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: TRANSFER_RECURRING_DISCRIMINATOR })
+  );
+}
+function getTransferRecurringInstructionDataDecoder() {
+  return (0, import_kit34.getStructDecoder)([
+    ["discriminator", (0, import_kit34.getU8Decoder)()],
+    ["transferData", getTransferDataDecoder()]
+  ]);
+}
+function getTransferRecurringInstructionDataCodec() {
+  return (0, import_kit34.combineCodec)(getTransferRecurringInstructionDataEncoder(), getTransferRecurringInstructionDataDecoder());
+}
+function getTransferRecurringInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    delegationPda: { value: input.delegationPda ?? null, isWritable: true },
+    subscriptionAuthority: { value: input.subscriptionAuthority ?? null, isWritable: false },
+    delegatorAta: { value: input.delegatorAta ?? null, isWritable: true },
+    receiverAta: { value: input.receiverAta ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    delegatee: { value: input.delegatee ?? null, isWritable: false },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = (0, import_program_client_core12.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("delegationPda", accounts.delegationPda),
+      getAccountMeta("subscriptionAuthority", accounts.subscriptionAuthority),
+      getAccountMeta("delegatorAta", accounts.delegatorAta),
+      getAccountMeta("receiverAta", accounts.receiverAta),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+      getAccountMeta("delegatee", accounts.delegatee),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getTransferRecurringInstructionDataEncoder().encode(args),
+    programAddress
+  });
+}
+function parseTransferRecurringInstruction(instruction) {
+  if (instruction.accounts.length < 8) {
+    throw new import_kit34.SolanaError(import_kit34.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 8
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      delegationPda: getNextAccount(),
+      subscriptionAuthority: getNextAccount(),
+      delegatorAta: getNextAccount(),
+      receiverAta: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      delegatee: getNextAccount(),
+      eventAuthority: getNextAccount(),
+      selfProgram: getNextAccount()
+    },
+    data: getTransferRecurringInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/transferSubscription.ts
+var import_kit35 = require("@solana/kit");
+var import_program_client_core13 = require("@solana/program-client-core");
+var TRANSFER_SUBSCRIPTION_DISCRIMINATOR = 10;
+function getTransferSubscriptionDiscriminatorBytes() {
+  return (0, import_kit35.getU8Encoder)().encode(TRANSFER_SUBSCRIPTION_DISCRIMINATOR);
+}
+function getTransferSubscriptionInstructionDataEncoder() {
+  return (0, import_kit35.transformEncoder)(
+    (0, import_kit35.getStructEncoder)([
+      ["discriminator", (0, import_kit35.getU8Encoder)()],
+      ["transferData", getTransferDataEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: TRANSFER_SUBSCRIPTION_DISCRIMINATOR })
+  );
+}
+function getTransferSubscriptionInstructionDataDecoder() {
+  return (0, import_kit35.getStructDecoder)([
+    ["discriminator", (0, import_kit35.getU8Decoder)()],
+    ["transferData", getTransferDataDecoder()]
+  ]);
+}
+function getTransferSubscriptionInstructionDataCodec() {
+  return (0, import_kit35.combineCodec)(
+    getTransferSubscriptionInstructionDataEncoder(),
+    getTransferSubscriptionInstructionDataDecoder()
+  );
+}
+function getTransferSubscriptionInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    subscriptionPda: { value: input.subscriptionPda ?? null, isWritable: true },
+    planPda: { value: input.planPda ?? null, isWritable: false },
+    subscriptionAuthority: { value: input.subscriptionAuthority ?? null, isWritable: false },
+    delegatorAta: { value: input.delegatorAta ?? null, isWritable: true },
+    receiverAta: { value: input.receiverAta ?? null, isWritable: true },
+    caller: { value: input.caller ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = (0, import_program_client_core13.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("subscriptionPda", accounts.subscriptionPda),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("subscriptionAuthority", accounts.subscriptionAuthority),
+      getAccountMeta("delegatorAta", accounts.delegatorAta),
+      getAccountMeta("receiverAta", accounts.receiverAta),
+      getAccountMeta("caller", accounts.caller),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getTransferSubscriptionInstructionDataEncoder().encode(args),
+    programAddress
+  });
+}
+function parseTransferSubscriptionInstruction(instruction) {
+  if (instruction.accounts.length < 9) {
+    throw new import_kit35.SolanaError(import_kit35.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 9
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      subscriptionPda: getNextAccount(),
+      planPda: getNextAccount(),
+      subscriptionAuthority: getNextAccount(),
+      delegatorAta: getNextAccount(),
+      receiverAta: getNextAccount(),
+      caller: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      eventAuthority: getNextAccount(),
+      selfProgram: getNextAccount()
+    },
+    data: getTransferSubscriptionInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/updatePlan.ts
+var import_kit36 = require("@solana/kit");
+var import_program_client_core14 = require("@solana/program-client-core");
+var UPDATE_PLAN_DISCRIMINATOR = 8;
+function getUpdatePlanDiscriminatorBytes() {
+  return (0, import_kit36.getU8Encoder)().encode(UPDATE_PLAN_DISCRIMINATOR);
+}
+function getUpdatePlanInstructionDataEncoder() {
+  return (0, import_kit36.transformEncoder)(
+    (0, import_kit36.getStructEncoder)([
+      ["discriminator", (0, import_kit36.getU8Encoder)()],
+      ["updatePlanData", getUpdatePlanDataEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: UPDATE_PLAN_DISCRIMINATOR })
+  );
+}
+function getUpdatePlanInstructionDataDecoder() {
+  return (0, import_kit36.getStructDecoder)([
+    ["discriminator", (0, import_kit36.getU8Decoder)()],
+    ["updatePlanData", getUpdatePlanDataDecoder()]
+  ]);
+}
+function getUpdatePlanInstructionDataCodec() {
+  return (0, import_kit36.combineCodec)(getUpdatePlanInstructionDataEncoder(), getUpdatePlanInstructionDataDecoder());
+}
+function getUpdatePlanInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    owner: { value: input.owner ?? null, isWritable: false },
+    planPda: { value: input.planPda ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = (0, import_program_client_core14.getAccountMetaFactory)(programAddress, "programId");
+  return Object.freeze({
+    accounts: [getAccountMeta("owner", accounts.owner), getAccountMeta("planPda", accounts.planPda)],
+    data: getUpdatePlanInstructionDataEncoder().encode(args),
+    programAddress
+  });
+}
+function parseUpdatePlanInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new import_kit36.SolanaError(import_kit36.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { owner: getNextAccount(), planPda: getNextAccount() },
+    data: getUpdatePlanInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/programs/subscriptions.ts
+var SUBSCRIPTIONS_PROGRAM_ADDRESS = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+var SubscriptionsAccount = /* @__PURE__ */ ((SubscriptionsAccount2) => {
+  SubscriptionsAccount2[SubscriptionsAccount2["FixedDelegation"] = 0] = "FixedDelegation";
+  SubscriptionsAccount2[SubscriptionsAccount2["Plan"] = 1] = "Plan";
+  SubscriptionsAccount2[SubscriptionsAccount2["RecurringDelegation"] = 2] = "RecurringDelegation";
+  SubscriptionsAccount2[SubscriptionsAccount2["SubscriptionAuthority"] = 3] = "SubscriptionAuthority";
+  SubscriptionsAccount2[SubscriptionsAccount2["SubscriptionDelegation"] = 4] = "SubscriptionDelegation";
+  SubscriptionsAccount2[SubscriptionsAccount2["EventAuthority"] = 5] = "EventAuthority";
+  return SubscriptionsAccount2;
+})(SubscriptionsAccount || {});
+var SubscriptionsInstruction = /* @__PURE__ */ ((SubscriptionsInstruction2) => {
+  SubscriptionsInstruction2[SubscriptionsInstruction2["InitSubscriptionAuthority"] = 0] = "InitSubscriptionAuthority";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["CreateFixedDelegation"] = 1] = "CreateFixedDelegation";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["CreateRecurringDelegation"] = 2] = "CreateRecurringDelegation";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["RevokeDelegation"] = 3] = "RevokeDelegation";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["TransferFixed"] = 4] = "TransferFixed";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["TransferRecurring"] = 5] = "TransferRecurring";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["CloseSubscriptionAuthority"] = 6] = "CloseSubscriptionAuthority";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["CreatePlan"] = 7] = "CreatePlan";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["UpdatePlan"] = 8] = "UpdatePlan";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["DeletePlan"] = 9] = "DeletePlan";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["TransferSubscription"] = 10] = "TransferSubscription";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["Subscribe"] = 11] = "Subscribe";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["CancelSubscription"] = 12] = "CancelSubscription";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["ResumeSubscription"] = 13] = "ResumeSubscription";
+  return SubscriptionsInstruction2;
+})(SubscriptionsInstruction || {});
+function identifySubscriptionsInstruction(instruction) {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(0), 0)) {
+    return 0 /* InitSubscriptionAuthority */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(1), 0)) {
+    return 1 /* CreateFixedDelegation */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(2), 0)) {
+    return 2 /* CreateRecurringDelegation */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(3), 0)) {
+    return 3 /* RevokeDelegation */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(4), 0)) {
+    return 4 /* TransferFixed */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(5), 0)) {
+    return 5 /* TransferRecurring */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(6), 0)) {
+    return 6 /* CloseSubscriptionAuthority */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(7), 0)) {
+    return 7 /* CreatePlan */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(8), 0)) {
+    return 8 /* UpdatePlan */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(9), 0)) {
+    return 9 /* DeletePlan */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(10), 0)) {
+    return 10 /* TransferSubscription */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(11), 0)) {
+    return 11 /* Subscribe */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(12), 0)) {
+    return 12 /* CancelSubscription */;
+  }
+  if ((0, import_kit37.containsBytes)(data, (0, import_kit37.getU8Encoder)().encode(13), 0)) {
+    return 13 /* ResumeSubscription */;
+  }
+  throw new import_kit37.SolanaError(import_kit37.SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
+    instructionData: data,
+    programName: "subscriptions"
+  });
+}
+function parseSubscriptionsInstruction(instruction) {
+  const instructionType = identifySubscriptionsInstruction(instruction);
+  switch (instructionType) {
+    case 0 /* InitSubscriptionAuthority */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 0 /* InitSubscriptionAuthority */,
+        ...parseInitSubscriptionAuthorityInstruction(instruction)
+      };
+    }
+    case 1 /* CreateFixedDelegation */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 1 /* CreateFixedDelegation */,
+        ...parseCreateFixedDelegationInstruction(instruction)
+      };
+    }
+    case 2 /* CreateRecurringDelegation */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 2 /* CreateRecurringDelegation */,
+        ...parseCreateRecurringDelegationInstruction(instruction)
+      };
+    }
+    case 3 /* RevokeDelegation */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 3 /* RevokeDelegation */,
+        ...parseRevokeDelegationInstruction(instruction)
+      };
+    }
+    case 4 /* TransferFixed */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 4 /* TransferFixed */,
+        ...parseTransferFixedInstruction(instruction)
+      };
+    }
+    case 5 /* TransferRecurring */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 5 /* TransferRecurring */,
+        ...parseTransferRecurringInstruction(instruction)
+      };
+    }
+    case 6 /* CloseSubscriptionAuthority */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 6 /* CloseSubscriptionAuthority */,
+        ...parseCloseSubscriptionAuthorityInstruction(instruction)
+      };
+    }
+    case 7 /* CreatePlan */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return { instructionType: 7 /* CreatePlan */, ...parseCreatePlanInstruction(instruction) };
+    }
+    case 8 /* UpdatePlan */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return { instructionType: 8 /* UpdatePlan */, ...parseUpdatePlanInstruction(instruction) };
+    }
+    case 9 /* DeletePlan */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return { instructionType: 9 /* DeletePlan */, ...parseDeletePlanInstruction(instruction) };
+    }
+    case 10 /* TransferSubscription */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 10 /* TransferSubscription */,
+        ...parseTransferSubscriptionInstruction(instruction)
+      };
+    }
+    case 11 /* Subscribe */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return { instructionType: 11 /* Subscribe */, ...parseSubscribeInstruction(instruction) };
+    }
+    case 12 /* CancelSubscription */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 12 /* CancelSubscription */,
+        ...parseCancelSubscriptionInstruction(instruction)
+      };
+    }
+    case 13 /* ResumeSubscription */: {
+      (0, import_kit37.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 13 /* ResumeSubscription */,
+        ...parseResumeSubscriptionInstruction(instruction)
+      };
+    }
+    default:
+      throw new import_kit37.SolanaError(import_kit37.SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
+        instructionType,
+        programName: "subscriptions"
+      });
+  }
+}
+function subscriptionsProgram() {
+  return (client) => {
+    return (0, import_kit37.extendClient)(client, {
+      subscriptions: {
+        accounts: {
+          fixedDelegation: (0, import_program_client_core15.addSelfFetchFunctions)(client, getFixedDelegationCodec()),
+          plan: (0, import_program_client_core15.addSelfFetchFunctions)(client, getPlanCodec()),
+          recurringDelegation: (0, import_program_client_core15.addSelfFetchFunctions)(client, getRecurringDelegationCodec()),
+          subscriptionAuthority: (0, import_program_client_core15.addSelfFetchFunctions)(client, getSubscriptionAuthorityCodec()),
+          subscriptionDelegation: (0, import_program_client_core15.addSelfFetchFunctions)(client, getSubscriptionDelegationCodec()),
+          eventAuthority: (0, import_program_client_core15.addSelfFetchFunctions)(client, getEventAuthorityCodec())
+        },
+        instructions: {
+          initSubscriptionAuthority: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getInitSubscriptionAuthorityInstructionAsync(input)),
+          createFixedDelegation: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getCreateFixedDelegationInstruction(input)),
+          createRecurringDelegation: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getCreateRecurringDelegationInstruction(input)),
+          revokeDelegation: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getRevokeDelegationInstruction(input)),
+          transferFixed: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getTransferFixedInstruction(input)),
+          transferRecurring: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getTransferRecurringInstruction(input)),
+          closeSubscriptionAuthority: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getCloseSubscriptionAuthorityInstruction(input)),
+          createPlan: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getCreatePlanInstruction(input)),
+          updatePlan: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getUpdatePlanInstruction(input)),
+          deletePlan: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getDeletePlanInstruction(input)),
+          transferSubscription: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getTransferSubscriptionInstruction(input)),
+          subscribe: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getSubscribeInstructionAsync(input)),
+          cancelSubscription: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getCancelSubscriptionInstructionAsync(input)),
+          resumeSubscription: (input) => (0, import_program_client_core15.addSelfPlanAndSendFunctions)(client, getResumeSubscriptionInstructionAsync(input))
+        },
+        pdas: {
+          fixedDelegation: findFixedDelegationPda,
+          plan: findPlanPda,
+          recurringDelegation: findRecurringDelegationPda,
+          subscriptionAuthority: findSubscriptionAuthorityPda,
+          subscriptionDelegation: findSubscriptionDelegationPda,
+          eventAuthority: findEventAuthorityPda
+        }
+      }
+    });
+  };
+}
+
+// src/generated/errors/subscriptions.ts
+var SUBSCRIPTIONS_ERROR__NOT_SIGNER = 100;
+var SUBSCRIPTIONS_ERROR__INVALID_ADDRESS = 101;
+var SUBSCRIPTIONS_ERROR__INVALID_ESCROW_PDA = 102;
+var SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_AUTHORITY_PDA = 103;
+var SUBSCRIPTIONS_ERROR__NOT_SYSTEM_PROGRAM = 104;
+var SUBSCRIPTIONS_ERROR__INVALID_TOKEN_PROGRAM = 105;
+var SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_MINT_ACCOUNT_DATA = 106;
+var SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_TOKEN_ACCOUNT_DATA = 107;
+var SUBSCRIPTIONS_ERROR__INVALID_ASSOCIATED_TOKEN_ACCOUNT_DERIVED_ADDRESS = 108;
+var SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_MINT_ACCOUNT_DATA = 109;
+var SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_TOKEN_ACCOUNT_DATA = 110;
+var SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DATA = 111;
+var SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION_DATA = 112;
+var SUBSCRIPTIONS_ERROR__NOT_ENOUGH_ACCOUNT_KEYS = 113;
+var SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION = 114;
+var SUBSCRIPTIONS_ERROR__ARITHMETIC_OVERFLOW = 115;
+var SUBSCRIPTIONS_ERROR__ARITHMETIC_UNDERFLOW = 116;
+var SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DISCRIMINATOR = 117;
+var SUBSCRIPTIONS_ERROR__MINT_HAS_CONFIDENTIAL_TRANSFER = 118;
+var SUBSCRIPTIONS_ERROR__MINT_HAS_NON_TRANSFERABLE = 119;
+var SUBSCRIPTIONS_ERROR__MINT_HAS_PERMANENT_DELEGATE = 120;
+var SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_HOOK = 121;
+var SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_FEE = 122;
+var SUBSCRIPTIONS_ERROR__MINT_HAS_MINT_CLOSE_AUTHORITY = 123;
+var SUBSCRIPTIONS_ERROR__MINT_HAS_PAUSABLE = 124;
+var SUBSCRIPTIONS_ERROR__MINT_MISMATCH = 125;
+var SUBSCRIPTIONS_ERROR__INVALID_DELEGATE_PDA = 126;
+var SUBSCRIPTIONS_ERROR__INVALID_HEADER_DATA = 127;
+var SUBSCRIPTIONS_ERROR__DELEGATION_EXPIRED = 128;
+var SUBSCRIPTIONS_ERROR__INVALID_AMOUNT = 129;
+var SUBSCRIPTIONS_ERROR__UNAUTHORIZED = 130;
+var SUBSCRIPTIONS_ERROR__ACCOUNT_NOT_WRITABLE = 131;
+var SUBSCRIPTIONS_ERROR__ATA_OWNER_MISMATCH = 132;
+var SUBSCRIPTIONS_ERROR__DELEGATION_VERSION_MISMATCH = 133;
+var SUBSCRIPTIONS_ERROR__MIGRATION_REQUIRED = 134;
+var SUBSCRIPTIONS_ERROR__DELEGATION_ALREADY_EXISTS = 135;
+var SUBSCRIPTIONS_ERROR__STALE_SUBSCRIPTION_AUTHORITY = 136;
+var SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_LIMIT = 300;
+var SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_EXPIRY_IN_PAST = 301;
+var SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_AMOUNT_ZERO = 302;
+var SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_PERIOD_LIMIT = 400;
+var SUBSCRIPTIONS_ERROR__PERIOD_NOT_ELAPSED = 401;
+var SUBSCRIPTIONS_ERROR__INVALID_PERIOD_LENGTH = 402;
+var SUBSCRIPTIONS_ERROR__INVALID_PAYER_DATA = 403;
+var SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_IN_PAST = 404;
+var SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_GREATER_THAN_EXPIRY = 405;
+var SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_AMOUNT_ZERO = 406;
+var SUBSCRIPTIONS_ERROR__DELEGATION_NOT_STARTED = 407;
+var SUBSCRIPTIONS_ERROR__PLAN_SUNSET = 500;
+var SUBSCRIPTIONS_ERROR__PLAN_EXPIRED = 501;
+var SUBSCRIPTIONS_ERROR__INVALID_PLAN_PDA = 502;
+var SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_PDA = 503;
+var SUBSCRIPTIONS_ERROR__NOT_PLAN_OWNER = 504;
+var SUBSCRIPTIONS_ERROR__SUBSCRIPTION_PLAN_MISMATCH = 505;
+var SUBSCRIPTIONS_ERROR__UNAUTHORIZED_DESTINATION = 506;
+var SUBSCRIPTIONS_ERROR__INVALID_NUM_DESTINATIONS = 507;
+var SUBSCRIPTIONS_ERROR__SUBSCRIPTION_CANCELLED = 508;
+var SUBSCRIPTIONS_ERROR__SUBSCRIPTION_ALREADY_CANCELLED = 509;
+var SUBSCRIPTIONS_ERROR__SUBSCRIPTION_NOT_CANCELLED = 510;
+var SUBSCRIPTIONS_ERROR__INVALID_END_TS = 511;
+var SUBSCRIPTIONS_ERROR__INVALID_PLAN_STATUS = 512;
+var SUBSCRIPTIONS_ERROR__PLAN_IMMUTABLE_AFTER_SUNSET = 513;
+var SUBSCRIPTIONS_ERROR__SUNSET_REQUIRES_END_TS = 514;
+var SUBSCRIPTIONS_ERROR__PLAN_NOT_EXPIRED = 515;
+var SUBSCRIPTIONS_ERROR__PLAN_CLOSED = 516;
+var SUBSCRIPTIONS_ERROR__ALREADY_SUBSCRIBED = 517;
+var SUBSCRIPTIONS_ERROR__PLAN_ALREADY_EXISTS = 518;
+var SUBSCRIPTIONS_ERROR__PLAN_TERMS_MISMATCH = 519;
+var SUBSCRIPTIONS_ERROR__INVALID_EVENT_AUTHORITY = 600;
+var SUBSCRIPTIONS_ERROR__INVALID_EVENT_DATA = 601;
+var SUBSCRIPTIONS_ERROR__INVALID_EVENT_TAG = 602;
+var SUBSCRIPTIONS_ERROR__INVALID_EVENT_DISCRIMINATOR = 603;
+var subscriptionsErrorMessages;
+if (process.env["NODE_ENV"] !== "production") {
+  subscriptionsErrorMessages = {
+    [SUBSCRIPTIONS_ERROR__ACCOUNT_NOT_WRITABLE]: `Account must be writable`,
+    [SUBSCRIPTIONS_ERROR__ALREADY_SUBSCRIBED]: `Already subscribed to this plan`,
+    [SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_LIMIT]: `Transfer amount exceeds delegation limit`,
+    [SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_PERIOD_LIMIT]: `Transfer amount exceeds period limit`,
+    [SUBSCRIPTIONS_ERROR__ARITHMETIC_OVERFLOW]: `Arithmetic Overflow`,
+    [SUBSCRIPTIONS_ERROR__ARITHMETIC_UNDERFLOW]: `Arithmetic Underflow`,
+    [SUBSCRIPTIONS_ERROR__ATA_OWNER_MISMATCH]: `Token account owner does not match expected`,
+    [SUBSCRIPTIONS_ERROR__DELEGATION_ALREADY_EXISTS]: `Delegation account already exists`,
+    [SUBSCRIPTIONS_ERROR__DELEGATION_EXPIRED]: `Delegation has expired`,
+    [SUBSCRIPTIONS_ERROR__DELEGATION_NOT_STARTED]: `Delegation period has not started yet`,
+    [SUBSCRIPTIONS_ERROR__DELEGATION_VERSION_MISMATCH]: `Delegation header version is not compatible`,
+    [SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_AMOUNT_ZERO]: `zero amount specified`,
+    [SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_EXPIRY_IN_PAST]: `Expiry time specified is less than current time`,
+    [SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DATA]: `Invalid account data`,
+    [SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DISCRIMINATOR]: `Invalid account discriminator`,
+    [SUBSCRIPTIONS_ERROR__INVALID_ADDRESS]: `Invalid account address`,
+    [SUBSCRIPTIONS_ERROR__INVALID_AMOUNT]: `Invalid amount specified`,
+    [SUBSCRIPTIONS_ERROR__INVALID_ASSOCIATED_TOKEN_ACCOUNT_DERIVED_ADDRESS]: `Invalid associated token account address`,
+    [SUBSCRIPTIONS_ERROR__INVALID_DELEGATE_PDA]: `Invalid delegation PDA derivation`,
+    [SUBSCRIPTIONS_ERROR__INVALID_END_TS]: `End timestamp must be zero or in the future`,
+    [SUBSCRIPTIONS_ERROR__INVALID_ESCROW_PDA]: `Invalid escrow PDA derivation`,
+    [SUBSCRIPTIONS_ERROR__INVALID_EVENT_AUTHORITY]: `Invalid event authority PDA`,
+    [SUBSCRIPTIONS_ERROR__INVALID_EVENT_DATA]: `Invalid event data`,
+    [SUBSCRIPTIONS_ERROR__INVALID_EVENT_DISCRIMINATOR]: `Unknown event discriminator`,
+    [SUBSCRIPTIONS_ERROR__INVALID_EVENT_TAG]: `Invalid event tag prefix`,
+    [SUBSCRIPTIONS_ERROR__INVALID_HEADER_DATA]: `Invalid header data`,
+    [SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION]: `Invalid instruction`,
+    [SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION_DATA]: `Invalid instruction data`,
+    [SUBSCRIPTIONS_ERROR__INVALID_NUM_DESTINATIONS]: `No valid destinations provided`,
+    [SUBSCRIPTIONS_ERROR__INVALID_PAYER_DATA]: `Payer provided does not match delegation`,
+    [SUBSCRIPTIONS_ERROR__INVALID_PERIOD_LENGTH]: `Invalid Period length`,
+    [SUBSCRIPTIONS_ERROR__INVALID_PLAN_PDA]: `Invalid Plan PDA derivation`,
+    [SUBSCRIPTIONS_ERROR__INVALID_PLAN_STATUS]: `Invalid plan status value`,
+    [SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_AUTHORITY_PDA]: `Invalid subscription-authority PDA derivation`,
+    [SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_PDA]: `Invalid subscription PDA derivation`,
+    [SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_MINT_ACCOUNT_DATA]: `Invalid Token-2022 mint account data`,
+    [SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_TOKEN_ACCOUNT_DATA]: `Invalid Token-2022 token account data`,
+    [SUBSCRIPTIONS_ERROR__INVALID_TOKEN_PROGRAM]: `Token Program does not match other accounts`,
+    [SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_MINT_ACCOUNT_DATA]: `Invalid SPL Token mint account data`,
+    [SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_TOKEN_ACCOUNT_DATA]: `Invalid SPL Token account data`,
+    [SUBSCRIPTIONS_ERROR__MIGRATION_REQUIRED]: `Account requires explicit migration`,
+    [SUBSCRIPTIONS_ERROR__MINT_HAS_CONFIDENTIAL_TRANSFER]: `Mint has ConfidentialTransfer extension`,
+    [SUBSCRIPTIONS_ERROR__MINT_HAS_MINT_CLOSE_AUTHORITY]: `Mint has MintCloseAuthority extension`,
+    [SUBSCRIPTIONS_ERROR__MINT_HAS_NON_TRANSFERABLE]: `Mint has NonTransferable extension`,
+    [SUBSCRIPTIONS_ERROR__MINT_HAS_PAUSABLE]: `Mint has Pausable extension`,
+    [SUBSCRIPTIONS_ERROR__MINT_HAS_PERMANENT_DELEGATE]: `Mint has PermanentDelegate extension`,
+    [SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_FEE]: `Mint has TransferFee extension`,
+    [SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_HOOK]: `Mint has TransferHook extension`,
+    [SUBSCRIPTIONS_ERROR__MINT_MISMATCH]: `Token mint mismatch`,
+    [SUBSCRIPTIONS_ERROR__NOT_ENOUGH_ACCOUNT_KEYS]: `Not enough account keys provided`,
+    [SUBSCRIPTIONS_ERROR__NOT_PLAN_OWNER]: `Caller is not the plan owner`,
+    [SUBSCRIPTIONS_ERROR__NOT_SIGNER]: `Account must be a signer`,
+    [SUBSCRIPTIONS_ERROR__NOT_SYSTEM_PROGRAM]: `Expected system program`,
+    [SUBSCRIPTIONS_ERROR__PERIOD_NOT_ELAPSED]: `Period has not elapsed yet`,
+    [SUBSCRIPTIONS_ERROR__PLAN_ALREADY_EXISTS]: `Plan account already exists`,
+    [SUBSCRIPTIONS_ERROR__PLAN_CLOSED]: `Plan account has been closed`,
+    [SUBSCRIPTIONS_ERROR__PLAN_EXPIRED]: `Plan has expired`,
+    [SUBSCRIPTIONS_ERROR__PLAN_IMMUTABLE_AFTER_SUNSET]: `Plan cannot be updated after sunset`,
+    [SUBSCRIPTIONS_ERROR__PLAN_NOT_EXPIRED]: `Plan must be expired to delete`,
+    [SUBSCRIPTIONS_ERROR__PLAN_SUNSET]: `Plan is in sunset status`,
+    [SUBSCRIPTIONS_ERROR__PLAN_TERMS_MISMATCH]: `Subscription plan terms do not match the current plan`,
+    [SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_AMOUNT_ZERO]: `zero amount specified`,
+    [SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_GREATER_THAN_EXPIRY]: `start time specified is greater than expiry`,
+    [SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_IN_PAST]: `Past start time specified`,
+    [SUBSCRIPTIONS_ERROR__STALE_SUBSCRIPTION_AUTHORITY]: `Delegation init_id does not match current SubscriptionAuthority`,
+    [SUBSCRIPTIONS_ERROR__SUBSCRIPTION_ALREADY_CANCELLED]: `Subscription already cancelled`,
+    [SUBSCRIPTIONS_ERROR__SUBSCRIPTION_CANCELLED]: `Subscription cancelled and past valid period`,
+    [SUBSCRIPTIONS_ERROR__SUBSCRIPTION_NOT_CANCELLED]: `Subscription is not cancelled`,
+    [SUBSCRIPTIONS_ERROR__SUBSCRIPTION_PLAN_MISMATCH]: `Subscription does not belong to this plan`,
+    [SUBSCRIPTIONS_ERROR__SUNSET_REQUIRES_END_TS]: `Sunset requires a non-zero end timestamp`,
+    [SUBSCRIPTIONS_ERROR__UNAUTHORIZED]: `Caller not authorized for this action`,
+    [SUBSCRIPTIONS_ERROR__UNAUTHORIZED_DESTINATION]: `Destination not in plan whitelist`
+  };
+}
+function getSubscriptionsErrorMessage(code) {
+  if (process.env["NODE_ENV"] !== "production") {
+    return subscriptionsErrorMessages[code];
+  }
+  return "Error message not available in production bundles.";
+}
+function isSubscriptionsError(error, transactionMessage, code) {
+  return (0, import_kit38.isProgramError)(error, transactionMessage, SUBSCRIPTIONS_PROGRAM_ADDRESS, code);
+}
+
+// src/constants.ts
+var PROGRAM_ID = SUBSCRIPTIONS_PROGRAM_ADDRESS;
+var CURRENT_PROGRAM_VERSION = 1;
+var ZERO_ADDRESS = "11111111111111111111111111111111";
+var DISCRIMINATOR_OFFSET = 0;
+var DELEGATOR_OFFSET = 3;
+var DELEGATEE_OFFSET = 35;
+var U64_BYTE_SIZE = 8;
+var SUBSCRIPTION_AUTHORITY_SEED = "SubscriptionAuthority";
+var DELEGATION_SEED = "delegation";
+var PLAN_SEED = "plan";
+var SUBSCRIPTION_SEED = "subscription";
+var EVENT_AUTHORITY_SEED = "event_authority";
+var PLAN_SIZE = 491;
+var SUBSCRIPTION_SIZE = 155;
+var PLAN_OWNER_OFFSET = 1;
+var MAX_PLAN_DESTINATIONS = 4;
+var MAX_PLAN_PULLERS = 4;
+var METADATA_URI_LEN = 128;
+
+// src/accounts/decode.ts
+function toEncodedAccount(raw, programAddress) {
+  const base64Encoder = (0, import_kit39.getBase64Encoder)();
+  const data = base64Encoder.encode(raw.account.data[0]);
+  return {
+    address: raw.pubkey,
+    data,
+    executable: raw.account.executable,
+    lamports: raw.account.lamports,
+    programAddress,
+    space: raw.account.space
+  };
+}
+function decodeDelegationAccount(raw, programAddress) {
+  const encoded = toEncodedAccount(raw, programAddress);
+  const kind = encoded.data[DISCRIMINATOR_OFFSET];
+  switch (kind) {
+    case 2 /* FixedDelegation */: {
+      const decoded = decodeFixedDelegation(encoded);
+      return {
+        address: raw.pubkey,
+        data: decoded.data,
+        kind: "fixed"
+      };
+    }
+    case 3 /* RecurringDelegation */: {
+      const decoded = decodeRecurringDelegation(encoded);
+      return {
+        address: raw.pubkey,
+        data: decoded.data,
+        kind: "recurring"
+      };
+    }
+    case 4 /* SubscriptionDelegation */: {
+      const decoded = decodeSubscriptionDelegation(encoded);
+      return {
+        address: raw.pubkey,
+        data: decoded.data,
+        kind: "subscription"
+      };
+    }
+    default:
+      console.warn(`Unknown delegation discriminator: ${kind}`);
+      return null;
+  }
+}
+
+// src/accounts/delegations.ts
+async function fetchDelegationsByDelegator(rpc, wallet, programAddress) {
+  return await fetchDelegationsByOffset(rpc, wallet, DELEGATOR_OFFSET, programAddress);
+}
+async function fetchDelegationsByDelegatee(rpc, wallet, programAddress) {
+  return await fetchDelegationsByOffset(rpc, wallet, DELEGATEE_OFFSET, programAddress);
+}
+async function fetchDelegationsByOffset(rpc, wallet, offset, programAddress) {
+  const progAddr = programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const response = await rpc.getProgramAccounts(progAddr, {
+    encoding: "base64",
+    filters: [
+      {
+        memcmp: {
+          bytes: wallet,
+          encoding: "base58",
+          offset: BigInt(offset)
+        }
+      }
+    ]
+  }).send();
+  return response.map((account) => decodeDelegationAccount(account, progAddr)).filter((d) => d !== null);
+}
+
+// src/accounts/plans.ts
+async function fetchPlansForOwner(rpc, owner, programAddress) {
+  const progAddr = programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const response = await rpc.getProgramAccounts(progAddr, {
+    encoding: "base64",
+    filters: [
+      { dataSize: BigInt(PLAN_SIZE) },
+      {
+        memcmp: {
+          bytes: owner,
+          encoding: "base58",
+          offset: BigInt(PLAN_OWNER_OFFSET)
+        }
+      }
+    ]
+  }).send();
+  return response.map((account) => {
+    const encoded = toEncodedAccount(account, progAddr);
+    const { address, data } = decodePlan(encoded);
+    return { address, data };
+  });
+}
+
+// src/accounts/subscriptions.ts
+async function fetchSubscriptionsForUser(rpc, user, programAddress) {
+  const progAddr = programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const response = await rpc.getProgramAccounts(progAddr, {
+    encoding: "base64",
+    filters: [
+      { dataSize: BigInt(SUBSCRIPTION_SIZE) },
+      {
+        memcmp: {
+          bytes: user,
+          encoding: "base58",
+          offset: BigInt(DELEGATOR_OFFSET)
+        }
+      }
+    ]
+  }).send();
+  return response.map((account) => {
+    const raw = account;
+    const encoded = toEncodedAccount(raw, progAddr);
+    const decoded = decodeSubscriptionDelegation(encoded);
+    return { address: raw.pubkey, data: decoded.data };
+  });
+}
+
+// src/plugin.ts
+var import_kit40 = require("@solana/kit");
+var import_program_client_core16 = require("@solana/program-client-core");
+var import_token = require("@solana-program/token");
+
+// src/validators.ts
+var textEncoder = new TextEncoder();
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+function assertPositive(value, name) {
+  if (BigInt(value) <= 0n) throw new ValidationError(`${name} must be greater than zero`);
+}
+function assertMetadataUri(metadataUri) {
+  if (textEncoder.encode(metadataUri).length > METADATA_URI_LEN)
+    throw new ValidationError(`metadataUri exceeds ${METADATA_URI_LEN} bytes`);
+}
+function assertMaxLen(arr, max, name) {
+  if (arr.length > max) throw new ValidationError(`${name} must have at most ${max} entries`);
+}
+function padAddresses(addresses, maxLen) {
+  return Array.from({ length: maxLen }, (_, i) => addresses[i] ?? ZERO_ADDRESS);
+}
+function padPlanDestinations(addresses) {
+  assertMaxLen(addresses, MAX_PLAN_DESTINATIONS, "destinations");
+  return padAddresses(addresses, MAX_PLAN_DESTINATIONS);
+}
+function padPlanPullers(addresses) {
+  assertMaxLen(addresses, MAX_PLAN_PULLERS, "pullers");
+  return padAddresses(addresses, MAX_PLAN_PULLERS);
+}
+
+// src/plugin.ts
+function pdaConfig(programAddress) {
+  return programAddress ? { programAddress } : {};
+}
+function withTrailing(instruction, trailing) {
+  if (trailing.length === 0) return instruction;
+  const accounts = [
+    ...instruction.accounts ?? [],
+    ...trailing
+  ];
+  return { ...instruction, accounts };
+}
+function appendPayer(instruction, payer) {
+  if (!payer) return instruction;
+  return withTrailing(instruction, [
+    {
+      address: payer.address,
+      role: import_kit40.AccountRole.WRITABLE_SIGNER,
+      signer: payer
+    }
+  ]);
+}
+async function getInitSubscriptionAuthorityOverlayInstructionAsync(input) {
+  return appendPayer(
+    await getInitSubscriptionAuthorityInstructionAsync(
+      {
+        owner: input.owner,
+        tokenMint: input.tokenMint,
+        tokenProgram: input.tokenProgram,
+        userAta: input.userAta
+      },
+      pdaConfig(input.programAddress)
+    ),
+    input.payer
+  );
+}
+async function getCloseSubscriptionAuthorityOverlayInstructionAsync(input) {
+  const [subscriptionAuthority] = await findSubscriptionAuthorityPda(
+    { tokenMint: input.tokenMint, user: input.user.address },
+    pdaConfig(input.programAddress)
+  );
+  let ix = getCloseSubscriptionAuthorityInstruction(
+    { subscriptionAuthority, user: input.user },
+    pdaConfig(input.programAddress)
+  );
+  if (input.receiver) {
+    ix = withTrailing(ix, [{ address: input.receiver, role: import_kit40.AccountRole.WRITABLE }]);
+  }
+  return ix;
+}
+async function getCreateFixedDelegationOverlayInstructionAsync(input) {
+  assertPositive(input.amount, "amount");
+  const [subscriptionAuthority] = await findSubscriptionAuthorityPda(
+    { tokenMint: input.tokenMint, user: input.delegator.address },
+    pdaConfig(input.programAddress)
+  );
+  const [delegationPda] = await findFixedDelegationPda(
+    {
+      delegatee: input.delegatee,
+      delegator: input.delegator.address,
+      nonce: input.nonce,
+      subscriptionAuthority
+    },
+    pdaConfig(input.programAddress)
+  );
+  return appendPayer(
+    getCreateFixedDelegationInstruction(
+      {
+        delegatee: input.delegatee,
+        delegationAccount: delegationPda,
+        delegator: input.delegator,
+        fixedDelegation: {
+          amount: input.amount,
+          expiryTs: input.expiryTs,
+          nonce: input.nonce
+        },
+        subscriptionAuthority
+      },
+      pdaConfig(input.programAddress)
+    ),
+    input.payer
+  );
+}
+async function getCreateRecurringDelegationOverlayInstructionAsync(input) {
+  assertPositive(input.amountPerPeriod, "amountPerPeriod");
+  assertPositive(input.periodLengthS, "periodLengthS");
+  const [subscriptionAuthority] = await findSubscriptionAuthorityPda(
+    { tokenMint: input.tokenMint, user: input.delegator.address },
+    pdaConfig(input.programAddress)
+  );
+  const [delegationPda] = await findRecurringDelegationPda(
+    {
+      delegatee: input.delegatee,
+      delegator: input.delegator.address,
+      nonce: input.nonce,
+      subscriptionAuthority
+    },
+    pdaConfig(input.programAddress)
+  );
+  return appendPayer(
+    getCreateRecurringDelegationInstruction(
+      {
+        delegatee: input.delegatee,
+        delegationAccount: delegationPda,
+        delegator: input.delegator,
+        recurringDelegation: {
+          amountPerPeriod: input.amountPerPeriod,
+          expiryTs: input.expiryTs,
+          nonce: input.nonce,
+          periodLengthS: input.periodLengthS,
+          startTs: input.startTs
+        },
+        subscriptionAuthority
+      },
+      pdaConfig(input.programAddress)
+    ),
+    input.payer
+  );
+}
+function getRevokeDelegationOverlayInstruction(input) {
+  let ix = getRevokeDelegationInstruction(
+    {
+      authority: input.authority,
+      delegationAccount: input.delegationAccount
+    },
+    pdaConfig(input.programAddress)
+  );
+  if (input.receiver) {
+    ix = withTrailing(ix, [{ address: input.receiver, role: import_kit40.AccountRole.WRITABLE }]);
+  }
+  return ix;
+}
+function getRevokeSubscriptionOverlayInstruction(input) {
+  const trailing = [{ address: input.planPda, role: import_kit40.AccountRole.READONLY }];
+  if (input.receiver) {
+    trailing.push({ address: input.receiver, role: import_kit40.AccountRole.WRITABLE });
+  }
+  return withTrailing(
+    getRevokeDelegationInstruction(
+      {
+        authority: input.authority,
+        delegationAccount: input.subscriptionPda
+      },
+      pdaConfig(input.programAddress)
+    ),
+    trailing
+  );
+}
+async function getTransferDelegationOverlayInstructionAsync(input, getInstruction) {
+  assertPositive(input.amount, "amount");
+  const [subscriptionAuthority] = await findSubscriptionAuthorityPda(
+    { tokenMint: input.tokenMint, user: input.delegator },
+    pdaConfig(input.programAddress)
+  );
+  return getInstruction(
+    {
+      delegatee: input.delegatee,
+      delegationPda: input.delegationPda,
+      delegatorAta: input.delegatorAta,
+      receiverAta: input.receiverAta,
+      subscriptionAuthority,
+      tokenProgram: input.tokenProgram,
+      transferData: {
+        amount: input.amount,
+        delegator: input.delegator,
+        mint: input.tokenMint
+      }
+    },
+    pdaConfig(input.programAddress)
+  );
+}
+function getTransferFixedOverlayInstructionAsync(input) {
+  return getTransferDelegationOverlayInstructionAsync(input, getTransferFixedInstruction);
+}
+function getTransferRecurringOverlayInstructionAsync(input) {
+  return getTransferDelegationOverlayInstructionAsync(input, getTransferRecurringInstruction);
+}
+async function getTransferSubscriptionOverlayInstructionAsync(input) {
+  assertPositive(input.amount, "amount");
+  const [subscriptionAuthority] = await findSubscriptionAuthorityPda(
+    { tokenMint: input.tokenMint, user: input.delegator },
+    pdaConfig(input.programAddress)
+  );
+  const [delegatorAta] = await (0, import_token.findAssociatedTokenPda)({
+    mint: input.tokenMint,
+    owner: input.delegator,
+    tokenProgram: input.tokenProgram
+  });
+  return getTransferSubscriptionInstruction(
+    {
+      caller: input.caller,
+      delegatorAta,
+      planPda: input.planPda,
+      receiverAta: input.receiverAta,
+      subscriptionAuthority,
+      subscriptionPda: input.subscriptionPda,
+      tokenProgram: input.tokenProgram,
+      transferData: {
+        amount: input.amount,
+        delegator: input.delegator,
+        mint: input.tokenMint
+      }
+    },
+    pdaConfig(input.programAddress)
+  );
+}
+async function getCreatePlanOverlayInstructionAsync(input) {
+  assertPositive(input.amount, "amount");
+  assertPositive(input.periodHours, "periodHours");
+  assertMetadataUri(input.metadataUri);
+  const destinations = padPlanDestinations(input.destinations);
+  const pullers = padPlanPullers(input.pullers);
+  const [planPda] = await findPlanPda(
+    { owner: input.owner.address, planId: input.planId },
+    pdaConfig(input.programAddress)
+  );
+  return getCreatePlanInstruction(
+    {
+      merchant: input.owner,
+      planData: {
+        destinations,
+        endTs: input.endTs,
+        metadataUri: input.metadataUri,
+        mint: input.mint,
+        planId: input.planId,
+        pullers,
+        terms: {
+          amount: input.amount,
+          createdAt: 0n,
+          periodHours: input.periodHours
+        }
+      },
+      planPda,
+      tokenMint: input.mint,
+      tokenProgram: input.tokenProgram
+    },
+    pdaConfig(input.programAddress)
+  );
+}
+function getUpdatePlanOverlayInstruction(input) {
+  assertMetadataUri(input.metadataUri);
+  const pullers = padPlanPullers(input.pullers ?? []);
+  return getUpdatePlanInstruction(
+    {
+      owner: input.owner,
+      planPda: input.planPda,
+      updatePlanData: {
+        endTs: input.endTs,
+        metadataUri: input.metadataUri,
+        pullers,
+        status: input.status
+      }
+    },
+    pdaConfig(input.programAddress)
+  );
+}
+function getDeletePlanOverlayInstruction(input) {
+  return getDeletePlanInstruction({ owner: input.owner, planPda: input.planPda }, pdaConfig(input.programAddress));
+}
+async function getSubscribeOverlayInstructionAsync(input) {
+  if (input.expectedAmount === void 0 || input.expectedPeriodHours === void 0 || input.expectedCreatedAt === void 0) {
+    throw new Error(
+      "getSubscribeOverlayInstructionAsync requires expectedAmount, expectedPeriodHours, and expectedCreatedAt. Use the plugin client `subscriptions.instructions.subscribe(...)` to auto-fetch from the live plan."
+    );
+  }
+  const [planPda, planBump] = await findPlanPda(
+    { owner: input.merchant, planId: input.planId },
+    pdaConfig(input.programAddress)
+  );
+  const [subscriptionAuthorityPda] = await findSubscriptionAuthorityPda(
+    { tokenMint: input.tokenMint, user: input.subscriber.address },
+    pdaConfig(input.programAddress)
+  );
+  return appendPayer(
+    await getSubscribeInstructionAsync(
+      {
+        merchant: input.merchant,
+        planPda,
+        subscribeData: {
+          expectedAmount: input.expectedAmount,
+          expectedCreatedAt: input.expectedCreatedAt,
+          expectedMint: input.tokenMint,
+          expectedPeriodHours: input.expectedPeriodHours,
+          planBump,
+          planId: input.planId
+        },
+        subscriber: input.subscriber,
+        subscriptionAuthorityPda
+      },
+      pdaConfig(input.programAddress)
+    ),
+    input.payer
+  );
+}
+function getCancelSubscriptionOverlayInstructionAsync(input) {
+  return getCancelSubscriptionInstructionAsync(
+    {
+      planPda: input.planPda,
+      subscriber: input.subscriber,
+      subscriptionPda: input.subscriptionPda
+    },
+    pdaConfig(input.programAddress)
+  );
+}
+function getResumeSubscriptionOverlayInstructionAsync(input) {
+  return getResumeSubscriptionInstructionAsync(
+    {
+      planPda: input.planPda,
+      subscriber: input.subscriber,
+      subscriptionPda: input.subscriptionPda
+    },
+    pdaConfig(input.programAddress)
+  );
+}
+function subscriptionsProgram2() {
+  return (client) => {
+    return (0, import_kit40.pipe)(client, subscriptionsProgram(), (c) => {
+      const queries = {
+        activeDelegationSummary: async (wallet) => {
+          const delegations = await fetchDelegationsByDelegator(c.rpc, wallet);
+          let fixed = 0;
+          let recurring = 0;
+          let subscriptions = 0;
+          for (const d of delegations) {
+            if (d.kind === "fixed") fixed++;
+            else if (d.kind === "recurring") recurring++;
+            else if (d.kind === "subscription") subscriptions++;
+          }
+          return { fixed, recurring, subscriptions, total: delegations.length };
+        },
+        delegationsByDelegatee: (wallet) => fetchDelegationsByDelegatee(c.rpc, wallet),
+        delegationsByDelegator: (wallet) => fetchDelegationsByDelegator(c.rpc, wallet),
+        isSubscriptionAuthorityInitialized: async (user, tokenMint, programAddress) => {
+          const [pda] = await findSubscriptionAuthorityPda({ tokenMint, user }, pdaConfig(programAddress));
+          const account = await fetchMaybeSubscriptionAuthority(c.rpc, pda);
+          return { initialized: account.exists, pda };
+        },
+        plansForOwner: (owner) => fetchPlansForOwner(c.rpc, owner)
+      };
+      const instructions = {
+        cancelSubscription: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getCancelSubscriptionOverlayInstructionAsync({
+            ...input,
+            subscriber: input.subscriber ?? client.identity
+          })
+        ),
+        closeSubscriptionAuthority: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getCloseSubscriptionAuthorityOverlayInstructionAsync({
+            ...input,
+            user: input.user ?? client.identity
+          })
+        ),
+        createFixedDelegation: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getCreateFixedDelegationOverlayInstructionAsync({
+            ...input,
+            delegator: input.delegator ?? client.identity,
+            payer: input.payer ?? (client.payer === client.identity ? void 0 : client.payer)
+          })
+        ),
+        createPlan: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getCreatePlanOverlayInstructionAsync({
+            ...input,
+            owner: input.owner ?? client.identity
+          })
+        ),
+        createRecurringDelegation: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getCreateRecurringDelegationOverlayInstructionAsync({
+            ...input,
+            delegator: input.delegator ?? client.identity,
+            payer: input.payer ?? (client.payer === client.identity ? void 0 : client.payer)
+          })
+        ),
+        deletePlan: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getDeletePlanOverlayInstruction({
+            ...input,
+            owner: input.owner ?? client.identity
+          })
+        ),
+        initSubscriptionAuthority: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getInitSubscriptionAuthorityOverlayInstructionAsync({
+            ...input,
+            owner: input.owner ?? client.identity,
+            payer: input.payer ?? (client.payer === client.identity ? void 0 : client.payer)
+          })
+        ),
+        resumeSubscription: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getResumeSubscriptionOverlayInstructionAsync({
+            ...input,
+            subscriber: input.subscriber ?? client.identity
+          })
+        ),
+        revokeDelegation: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getRevokeDelegationOverlayInstruction({
+            ...input,
+            authority: input.authority ?? client.identity
+          })
+        ),
+        revokeSubscription: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getRevokeSubscriptionOverlayInstruction({
+            ...input,
+            authority: input.authority ?? client.identity
+          })
+        ),
+        subscribe: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          (async () => {
+            let { expectedAmount, expectedPeriodHours, expectedCreatedAt } = input;
+            if (expectedAmount === void 0 || expectedPeriodHours === void 0 || expectedCreatedAt === void 0) {
+              const subscriber = input.subscriber ?? client.identity;
+              const [planPda] = await findPlanPda(
+                { owner: input.merchant, planId: input.planId },
+                pdaConfig(input.programAddress)
+              );
+              const plan = await fetchPlan(c.rpc, planPda);
+              expectedAmount = expectedAmount ?? plan.data.data.terms.amount;
+              expectedPeriodHours = expectedPeriodHours ?? plan.data.data.terms.periodHours;
+              expectedCreatedAt = expectedCreatedAt ?? plan.data.data.terms.createdAt;
+              return await getSubscribeOverlayInstructionAsync({
+                ...input,
+                expectedAmount,
+                expectedCreatedAt,
+                expectedPeriodHours,
+                payer: input.payer ?? (client.payer === client.identity ? void 0 : client.payer),
+                subscriber
+              });
+            }
+            return await getSubscribeOverlayInstructionAsync({
+              ...input,
+              expectedAmount,
+              expectedCreatedAt,
+              expectedPeriodHours,
+              payer: input.payer ?? (client.payer === client.identity ? void 0 : client.payer),
+              subscriber: input.subscriber ?? client.identity
+            });
+          })()
+        ),
+        transferFixed: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getTransferFixedOverlayInstructionAsync({
+            ...input,
+            delegatee: input.delegatee ?? client.identity
+          })
+        ),
+        transferRecurring: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getTransferRecurringOverlayInstructionAsync({
+            ...input,
+            delegatee: input.delegatee ?? client.identity
+          })
+        ),
+        transferSubscription: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getTransferSubscriptionOverlayInstructionAsync({
+            ...input,
+            caller: input.caller ?? client.identity
+          })
+        ),
+        updatePlan: (input) => (0, import_program_client_core16.addSelfPlanAndSendFunctions)(
+          client,
+          getUpdatePlanOverlayInstruction({
+            ...input,
+            owner: input.owner ?? client.identity
+          })
+        )
+      };
+      return {
+        ...c,
+        subscriptions: {
+          ...c.subscriptions,
+          instructions,
+          queries
+        }
+      };
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountDiscriminator,
+  CANCEL_SUBSCRIPTION_DISCRIMINATOR,
+  CLOSE_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR,
+  CREATE_FIXED_DELEGATION_DISCRIMINATOR,
+  CREATE_PLAN_DISCRIMINATOR,
+  CREATE_RECURRING_DELEGATION_DISCRIMINATOR,
+  CURRENT_PROGRAM_VERSION,
+  DELEGATEE_OFFSET,
+  DELEGATION_SEED,
+  DELEGATOR_OFFSET,
+  DELETE_PLAN_DISCRIMINATOR,
+  DISCRIMINATOR_OFFSET,
+  EVENT_AUTHORITY_SEED,
+  INIT_SUBSCRIPTION_AUTHORITY_DISCRIMINATOR,
+  MAX_PLAN_DESTINATIONS,
+  MAX_PLAN_PULLERS,
+  METADATA_URI_LEN,
+  PLAN_OWNER_OFFSET,
+  PLAN_SEED,
+  PLAN_SIZE,
+  PROGRAM_ID,
+  PlanStatus,
+  RESUME_SUBSCRIPTION_DISCRIMINATOR,
+  REVOKE_DELEGATION_DISCRIMINATOR,
+  SUBSCRIBE_DISCRIMINATOR,
+  SUBSCRIPTIONS_ERROR__ACCOUNT_NOT_WRITABLE,
+  SUBSCRIPTIONS_ERROR__ALREADY_SUBSCRIBED,
+  SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_LIMIT,
+  SUBSCRIPTIONS_ERROR__AMOUNT_EXCEEDS_PERIOD_LIMIT,
+  SUBSCRIPTIONS_ERROR__ARITHMETIC_OVERFLOW,
+  SUBSCRIPTIONS_ERROR__ARITHMETIC_UNDERFLOW,
+  SUBSCRIPTIONS_ERROR__ATA_OWNER_MISMATCH,
+  SUBSCRIPTIONS_ERROR__DELEGATION_ALREADY_EXISTS,
+  SUBSCRIPTIONS_ERROR__DELEGATION_EXPIRED,
+  SUBSCRIPTIONS_ERROR__DELEGATION_NOT_STARTED,
+  SUBSCRIPTIONS_ERROR__DELEGATION_VERSION_MISMATCH,
+  SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_AMOUNT_ZERO,
+  SUBSCRIPTIONS_ERROR__FIXED_DELEGATION_EXPIRY_IN_PAST,
+  SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_ACCOUNT_DISCRIMINATOR,
+  SUBSCRIPTIONS_ERROR__INVALID_ADDRESS,
+  SUBSCRIPTIONS_ERROR__INVALID_AMOUNT,
+  SUBSCRIPTIONS_ERROR__INVALID_ASSOCIATED_TOKEN_ACCOUNT_DERIVED_ADDRESS,
+  SUBSCRIPTIONS_ERROR__INVALID_DELEGATE_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_END_TS,
+  SUBSCRIPTIONS_ERROR__INVALID_ESCROW_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_EVENT_AUTHORITY,
+  SUBSCRIPTIONS_ERROR__INVALID_EVENT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_EVENT_DISCRIMINATOR,
+  SUBSCRIPTIONS_ERROR__INVALID_EVENT_TAG,
+  SUBSCRIPTIONS_ERROR__INVALID_HEADER_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION,
+  SUBSCRIPTIONS_ERROR__INVALID_INSTRUCTION_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_NUM_DESTINATIONS,
+  SUBSCRIPTIONS_ERROR__INVALID_PAYER_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_PERIOD_LENGTH,
+  SUBSCRIPTIONS_ERROR__INVALID_PLAN_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_PLAN_STATUS,
+  SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_AUTHORITY_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_SUBSCRIPTION_PDA,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_MINT_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN2022_TOKEN_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN_PROGRAM,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_MINT_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__INVALID_TOKEN_SPL_TOKEN_ACCOUNT_DATA,
+  SUBSCRIPTIONS_ERROR__MIGRATION_REQUIRED,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_CONFIDENTIAL_TRANSFER,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_MINT_CLOSE_AUTHORITY,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_NON_TRANSFERABLE,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_PAUSABLE,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_PERMANENT_DELEGATE,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_FEE,
+  SUBSCRIPTIONS_ERROR__MINT_HAS_TRANSFER_HOOK,
+  SUBSCRIPTIONS_ERROR__MINT_MISMATCH,
+  SUBSCRIPTIONS_ERROR__NOT_ENOUGH_ACCOUNT_KEYS,
+  SUBSCRIPTIONS_ERROR__NOT_PLAN_OWNER,
+  SUBSCRIPTIONS_ERROR__NOT_SIGNER,
+  SUBSCRIPTIONS_ERROR__NOT_SYSTEM_PROGRAM,
+  SUBSCRIPTIONS_ERROR__PERIOD_NOT_ELAPSED,
+  SUBSCRIPTIONS_ERROR__PLAN_ALREADY_EXISTS,
+  SUBSCRIPTIONS_ERROR__PLAN_CLOSED,
+  SUBSCRIPTIONS_ERROR__PLAN_EXPIRED,
+  SUBSCRIPTIONS_ERROR__PLAN_IMMUTABLE_AFTER_SUNSET,
+  SUBSCRIPTIONS_ERROR__PLAN_NOT_EXPIRED,
+  SUBSCRIPTIONS_ERROR__PLAN_SUNSET,
+  SUBSCRIPTIONS_ERROR__PLAN_TERMS_MISMATCH,
+  SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_AMOUNT_ZERO,
+  SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_GREATER_THAN_EXPIRY,
+  SUBSCRIPTIONS_ERROR__RECURRING_DELEGATION_START_TIME_IN_PAST,
+  SUBSCRIPTIONS_ERROR__STALE_SUBSCRIPTION_AUTHORITY,
+  SUBSCRIPTIONS_ERROR__SUBSCRIPTION_ALREADY_CANCELLED,
+  SUBSCRIPTIONS_ERROR__SUBSCRIPTION_CANCELLED,
+  SUBSCRIPTIONS_ERROR__SUBSCRIPTION_NOT_CANCELLED,
+  SUBSCRIPTIONS_ERROR__SUBSCRIPTION_PLAN_MISMATCH,
+  SUBSCRIPTIONS_ERROR__SUNSET_REQUIRES_END_TS,
+  SUBSCRIPTIONS_ERROR__UNAUTHORIZED,
+  SUBSCRIPTIONS_ERROR__UNAUTHORIZED_DESTINATION,
+  SUBSCRIPTIONS_PROGRAM_ADDRESS,
+  SUBSCRIPTION_AUTHORITY_SEED,
+  SUBSCRIPTION_SEED,
+  SUBSCRIPTION_SIZE,
+  SubscriptionsAccount,
+  SubscriptionsInstruction,
+  TRANSFER_FIXED_DISCRIMINATOR,
+  TRANSFER_RECURRING_DISCRIMINATOR,
+  TRANSFER_SUBSCRIPTION_DISCRIMINATOR,
+  U64_BYTE_SIZE,
+  UPDATE_PLAN_DISCRIMINATOR,
+  ValidationError,
+  ZERO_ADDRESS,
+  decodeDelegationAccount,
+  decodeEventAuthority,
+  decodeFixedDelegation,
+  decodePlan,
+  decodeRecurringDelegation,
+  decodeSubscriptionAuthority,
+  decodeSubscriptionDelegation,
+  fetchAllEventAuthority,
+  fetchAllFixedDelegation,
+  fetchAllMaybeEventAuthority,
+  fetchAllMaybeFixedDelegation,
+  fetchAllMaybePlan,
+  fetchAllMaybeRecurringDelegation,
+  fetchAllMaybeSubscriptionAuthority,
+  fetchAllMaybeSubscriptionDelegation,
+  fetchAllPlan,
+  fetchAllRecurringDelegation,
+  fetchAllSubscriptionAuthority,
+  fetchAllSubscriptionDelegation,
+  fetchDelegationsByDelegatee,
+  fetchDelegationsByDelegator,
+  fetchEventAuthority,
+  fetchEventAuthorityFromSeeds,
+  fetchFixedDelegation,
+  fetchFixedDelegationFromSeeds,
+  fetchMaybeEventAuthority,
+  fetchMaybeEventAuthorityFromSeeds,
+  fetchMaybeFixedDelegation,
+  fetchMaybeFixedDelegationFromSeeds,
+  fetchMaybePlan,
+  fetchMaybePlanFromSeeds,
+  fetchMaybeRecurringDelegation,
+  fetchMaybeRecurringDelegationFromSeeds,
+  fetchMaybeSubscriptionAuthority,
+  fetchMaybeSubscriptionAuthorityFromSeeds,
+  fetchMaybeSubscriptionDelegation,
+  fetchMaybeSubscriptionDelegationFromSeeds,
+  fetchPlan,
+  fetchPlanFromSeeds,
+  fetchPlansForOwner,
+  fetchRecurringDelegation,
+  fetchRecurringDelegationFromSeeds,
+  fetchSubscriptionAuthority,
+  fetchSubscriptionAuthorityFromSeeds,
+  fetchSubscriptionDelegation,
+  fetchSubscriptionDelegationFromSeeds,
+  fetchSubscriptionsForUser,
+  findEventAuthorityPda,
+  findFixedDelegationPda,
+  findPlanPda,
+  findRecurringDelegationPda,
+  findSubscriptionAuthorityPda,
+  findSubscriptionDelegationPda,
+  getAccountDiscriminatorCodec,
+  getAccountDiscriminatorDecoder,
+  getAccountDiscriminatorEncoder,
+  getCancelSubscriptionDiscriminatorBytes,
+  getCancelSubscriptionInstruction,
+  getCancelSubscriptionInstructionAsync,
+  getCancelSubscriptionInstructionDataCodec,
+  getCancelSubscriptionInstructionDataDecoder,
+  getCancelSubscriptionInstructionDataEncoder,
+  getCancelSubscriptionOverlayInstructionAsync,
+  getCloseSubscriptionAuthorityDiscriminatorBytes,
+  getCloseSubscriptionAuthorityInstruction,
+  getCloseSubscriptionAuthorityInstructionDataCodec,
+  getCloseSubscriptionAuthorityInstructionDataDecoder,
+  getCloseSubscriptionAuthorityInstructionDataEncoder,
+  getCloseSubscriptionAuthorityOverlayInstructionAsync,
+  getCreateFixedDelegationDataCodec,
+  getCreateFixedDelegationDataDecoder,
+  getCreateFixedDelegationDataEncoder,
+  getCreateFixedDelegationDiscriminatorBytes,
+  getCreateFixedDelegationInstruction,
+  getCreateFixedDelegationInstructionDataCodec,
+  getCreateFixedDelegationInstructionDataDecoder,
+  getCreateFixedDelegationInstructionDataEncoder,
+  getCreateFixedDelegationOverlayInstructionAsync,
+  getCreatePlanDiscriminatorBytes,
+  getCreatePlanInstruction,
+  getCreatePlanInstructionDataCodec,
+  getCreatePlanInstructionDataDecoder,
+  getCreatePlanInstructionDataEncoder,
+  getCreatePlanOverlayInstructionAsync,
+  getCreateRecurringDelegationDataCodec,
+  getCreateRecurringDelegationDataDecoder,
+  getCreateRecurringDelegationDataEncoder,
+  getCreateRecurringDelegationDiscriminatorBytes,
+  getCreateRecurringDelegationInstruction,
+  getCreateRecurringDelegationInstructionDataCodec,
+  getCreateRecurringDelegationInstructionDataDecoder,
+  getCreateRecurringDelegationInstructionDataEncoder,
+  getCreateRecurringDelegationOverlayInstructionAsync,
+  getDeletePlanDiscriminatorBytes,
+  getDeletePlanInstruction,
+  getDeletePlanInstructionDataCodec,
+  getDeletePlanInstructionDataDecoder,
+  getDeletePlanInstructionDataEncoder,
+  getDeletePlanOverlayInstruction,
+  getEventAuthorityCodec,
+  getEventAuthorityDecoder,
+  getEventAuthorityEncoder,
+  getFixedDelegationCodec,
+  getFixedDelegationDecoder,
+  getFixedDelegationEncoder,
+  getHeaderCodec,
+  getHeaderDecoder,
+  getHeaderEncoder,
+  getInitSubscriptionAuthorityDiscriminatorBytes,
+  getInitSubscriptionAuthorityInstruction,
+  getInitSubscriptionAuthorityInstructionAsync,
+  getInitSubscriptionAuthorityInstructionDataCodec,
+  getInitSubscriptionAuthorityInstructionDataDecoder,
+  getInitSubscriptionAuthorityInstructionDataEncoder,
+  getInitSubscriptionAuthorityOverlayInstructionAsync,
+  getPlanCodec,
+  getPlanDataCodec,
+  getPlanDataDecoder,
+  getPlanDataEncoder,
+  getPlanDecoder,
+  getPlanEncoder,
+  getPlanStatusCodec,
+  getPlanStatusDecoder,
+  getPlanStatusEncoder,
+  getPlanTermsCodec,
+  getPlanTermsDecoder,
+  getPlanTermsEncoder,
+  getRecurringDelegationCodec,
+  getRecurringDelegationDecoder,
+  getRecurringDelegationEncoder,
+  getResumeSubscriptionDiscriminatorBytes,
+  getResumeSubscriptionInstruction,
+  getResumeSubscriptionInstructionAsync,
+  getResumeSubscriptionInstructionDataCodec,
+  getResumeSubscriptionInstructionDataDecoder,
+  getResumeSubscriptionInstructionDataEncoder,
+  getResumeSubscriptionOverlayInstructionAsync,
+  getRevokeDelegationDiscriminatorBytes,
+  getRevokeDelegationInstruction,
+  getRevokeDelegationInstructionDataCodec,
+  getRevokeDelegationInstructionDataDecoder,
+  getRevokeDelegationInstructionDataEncoder,
+  getRevokeDelegationOverlayInstruction,
+  getRevokeSubscriptionOverlayInstruction,
+  getSubscribeDataCodec,
+  getSubscribeDataDecoder,
+  getSubscribeDataEncoder,
+  getSubscribeDiscriminatorBytes,
+  getSubscribeInstruction,
+  getSubscribeInstructionAsync,
+  getSubscribeInstructionDataCodec,
+  getSubscribeInstructionDataDecoder,
+  getSubscribeInstructionDataEncoder,
+  getSubscribeOverlayInstructionAsync,
+  getSubscriptionAuthorityCodec,
+  getSubscriptionAuthorityDecoder,
+  getSubscriptionAuthorityEncoder,
+  getSubscriptionDelegationCodec,
+  getSubscriptionDelegationDecoder,
+  getSubscriptionDelegationEncoder,
+  getSubscriptionsErrorMessage,
+  getTransferDataCodec,
+  getTransferDataDecoder,
+  getTransferDataEncoder,
+  getTransferFixedDiscriminatorBytes,
+  getTransferFixedInstruction,
+  getTransferFixedInstructionDataCodec,
+  getTransferFixedInstructionDataDecoder,
+  getTransferFixedInstructionDataEncoder,
+  getTransferFixedOverlayInstructionAsync,
+  getTransferRecurringDiscriminatorBytes,
+  getTransferRecurringInstruction,
+  getTransferRecurringInstructionDataCodec,
+  getTransferRecurringInstructionDataDecoder,
+  getTransferRecurringInstructionDataEncoder,
+  getTransferRecurringOverlayInstructionAsync,
+  getTransferSubscriptionDiscriminatorBytes,
+  getTransferSubscriptionInstruction,
+  getTransferSubscriptionInstructionDataCodec,
+  getTransferSubscriptionInstructionDataDecoder,
+  getTransferSubscriptionInstructionDataEncoder,
+  getTransferSubscriptionOverlayInstructionAsync,
+  getUpdatePlanDataCodec,
+  getUpdatePlanDataDecoder,
+  getUpdatePlanDataEncoder,
+  getUpdatePlanDiscriminatorBytes,
+  getUpdatePlanInstruction,
+  getUpdatePlanInstructionDataCodec,
+  getUpdatePlanInstructionDataDecoder,
+  getUpdatePlanInstructionDataEncoder,
+  getUpdatePlanOverlayInstruction,
+  identifySubscriptionsInstruction,
+  isSubscriptionsError,
+  parseCancelSubscriptionInstruction,
+  parseCloseSubscriptionAuthorityInstruction,
+  parseCreateFixedDelegationInstruction,
+  parseCreatePlanInstruction,
+  parseCreateRecurringDelegationInstruction,
+  parseDeletePlanInstruction,
+  parseInitSubscriptionAuthorityInstruction,
+  parseResumeSubscriptionInstruction,
+  parseRevokeDelegationInstruction,
+  parseSubscribeInstruction,
+  parseSubscriptionsInstruction,
+  parseTransferFixedInstruction,
+  parseTransferRecurringInstruction,
+  parseTransferSubscriptionInstruction,
+  parseUpdatePlanInstruction,
+  subscriptionsProgram,
+  toEncodedAccount
+});
+//# sourceMappingURL=index.cjs.map