@1upmonster/duel 0.1.8 → 0.2.2

package/dist/generated/duel/instructions/setupTicketPermission.d.ts

@@ -0,0 +1,54 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export declare const SETUP_TICKET_PERMISSION_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getSetupTicketPermissionDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type SetupTicketPermissionInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TAccountPermission extends string | AccountMeta<string> = string, TAccountPermissionProgram extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? ReadonlyAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, TAccountPermission extends string ? WritableAccount<TAccountPermission> : TAccountPermission, TAccountPermissionProgram extends string ? ReadonlyAccount<TAccountPermissionProgram> : TAccountPermissionProgram, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+export type SetupTicketPermissionInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+export type SetupTicketPermissionInstructionDataArgs = {};
+export declare function getSetupTicketPermissionInstructionDataEncoder(): FixedSizeEncoder<SetupTicketPermissionInstructionDataArgs>;
+export declare function getSetupTicketPermissionInstructionDataDecoder(): FixedSizeDecoder<SetupTicketPermissionInstructionData>;
+export declare function getSetupTicketPermissionInstructionDataCodec(): FixedSizeCodec<SetupTicketPermissionInstructionDataArgs, SetupTicketPermissionInstructionData>;
+export type SetupTicketPermissionAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string, TAccountPermission extends string = string, TAccountPermissionProgram extends string = string, TAccountSystemProgram extends string = string> = {
+    ticket?: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+    permission: Address<TAccountPermission>;
+    permissionProgram: Address<TAccountPermissionProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+};
+export declare function getSetupTicketPermissionInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TAccountPermission extends string, TAccountPermissionProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: SetupTicketPermissionAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<SetupTicketPermissionInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>>;
+export type SetupTicketPermissionInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string, TAccountPermission extends string = string, TAccountPermissionProgram extends string = string, TAccountSystemProgram extends string = string> = {
+    ticket: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+    permission: Address<TAccountPermission>;
+    permissionProgram: Address<TAccountPermissionProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+};
+export declare function getSetupTicketPermissionInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TAccountPermission extends string, TAccountPermissionProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: SetupTicketPermissionInput<TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): SetupTicketPermissionInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>;
+export type ParsedSetupTicketPermissionInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        ticket: TAccountMetas[0];
+        tenant: TAccountMetas[1];
+        player: TAccountMetas[2];
+        permission: TAccountMetas[3];
+        permissionProgram: TAccountMetas[4];
+        systemProgram: TAccountMetas[5];
+    };
+    data: SetupTicketPermissionInstructionData;
+};
+export declare function parseSetupTicketPermissionInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSetupTicketPermissionInstruction<TProgram, TAccountMetas>;

package/dist/generated/duel/instructions/setupTicketPermission.js

@@ -0,0 +1,63 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export const SETUP_TICKET_PERMISSION_DISCRIMINATOR = new Uint8Array([164, 29, 7, 235, 183, 223, 11, 85]);
+export function getSetupTicketPermissionDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(SETUP_TICKET_PERMISSION_DISCRIMINATOR); }
+export function getSetupTicketPermissionInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: SETUP_TICKET_PERMISSION_DISCRIMINATOR }));
+}
+export function getSetupTicketPermissionInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getSetupTicketPermissionInstructionDataCodec() {
+    return combineCodec(getSetupTicketPermissionInstructionDataEncoder(), getSetupTicketPermissionInstructionDataDecoder());
+}
+export async function getSetupTicketPermissionInstructionAsync(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: false }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true }, permission: { value: input.permission ?? null, isWritable: true }, permissionProgram: { value: input.permissionProgram ?? null, isWritable: false }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.ticket.value) {
+        accounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("tenant", accounts.tenant.value))] });
+    }
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '11111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player), getAccountMeta("permission", accounts.permission), getAccountMeta("permissionProgram", accounts.permissionProgram), getAccountMeta("systemProgram", accounts.systemProgram)], data: getSetupTicketPermissionInstructionDataEncoder().encode({}), programAddress });
+}
+export function getSetupTicketPermissionInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: false }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true }, permission: { value: input.permission ?? null, isWritable: true }, permissionProgram: { value: input.permissionProgram ?? null, isWritable: false }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '11111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player), getAccountMeta("permission", accounts.permission), getAccountMeta("permissionProgram", accounts.permissionProgram), getAccountMeta("systemProgram", accounts.systemProgram)], data: getSetupTicketPermissionInstructionDataEncoder().encode({}), programAddress });
+}
+export function parseSetupTicketPermissionInstruction(instruction) {
+    if (instruction.accounts.length < 6) {
+        throw new SolanaError(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: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount(), permission: getNextAccount(), permissionProgram: getNextAccount(), systemProgram: getNextAccount() }, data: getSetupTicketPermissionInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"setupTicketPermission.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/setupTicketPermission.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';\nimport { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { DUEL_PROGRAM_ADDRESS } from '../programs';\n\nexport const SETUP_TICKET_PERMISSION_DISCRIMINATOR = new Uint8Array([164, 29, 7, 235, 183, 223, 11, 85]);\n\nexport function getSetupTicketPermissionDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(SETUP_TICKET_PERMISSION_DISCRIMINATOR); }\n\nexport type SetupTicketPermissionInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TAccountPermission extends string | AccountMeta<string> = string, TAccountPermissionProgram extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = \"11111111111111111111111111111111\", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? ReadonlyAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, TAccountPermission extends string ? WritableAccount<TAccountPermission> : TAccountPermission, TAccountPermissionProgram extends string ? ReadonlyAccount<TAccountPermissionProgram> : TAccountPermissionProgram, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;\n\nexport type SetupTicketPermissionInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type SetupTicketPermissionInstructionDataArgs = {  };\n\nexport function getSetupTicketPermissionInstructionDataEncoder(): FixedSizeEncoder<SetupTicketPermissionInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: SETUP_TICKET_PERMISSION_DISCRIMINATOR }));\n}\n\nexport function getSetupTicketPermissionInstructionDataDecoder(): FixedSizeDecoder<SetupTicketPermissionInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getSetupTicketPermissionInstructionDataCodec(): FixedSizeCodec<SetupTicketPermissionInstructionDataArgs, SetupTicketPermissionInstructionData> {\n    return combineCodec(getSetupTicketPermissionInstructionDataEncoder(), getSetupTicketPermissionInstructionDataDecoder());\n}\n\nexport type SetupTicketPermissionAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string, TAccountPermission extends string = string, TAccountPermissionProgram extends string = string, TAccountSystemProgram extends string = string> =  {\n  ticket?: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\npermission: Address<TAccountPermission>;\npermissionProgram: Address<TAccountPermissionProgram>;\nsystemProgram?: Address<TAccountSystemProgram>;\n}\n\nexport async function getSetupTicketPermissionInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TAccountPermission extends string, TAccountPermissionProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: SetupTicketPermissionAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): Promise<SetupTicketPermissionInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: false }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true }, permission: { value: input.permission ?? null, isWritable: true }, permissionProgram: { value: input.permissionProgram ?? null, isWritable: false }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.ticket.value) {\naccounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"player\", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"tenant\", accounts.tenant.value))] });\n}\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player), getAccountMeta(\"permission\", accounts.permission), getAccountMeta(\"permissionProgram\", accounts.permissionProgram), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getSetupTicketPermissionInstructionDataEncoder().encode({}), programAddress } as SetupTicketPermissionInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>);\n}\n\nexport type SetupTicketPermissionInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string, TAccountPermission extends string = string, TAccountPermissionProgram extends string = string, TAccountSystemProgram extends string = string> =  {\n  ticket: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\npermission: Address<TAccountPermission>;\npermissionProgram: Address<TAccountPermissionProgram>;\nsystemProgram?: Address<TAccountSystemProgram>;\n}\n\nexport function getSetupTicketPermissionInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TAccountPermission extends string, TAccountPermissionProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: SetupTicketPermissionInput<TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): SetupTicketPermissionInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: false }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true }, permission: { value: input.permission ?? null, isWritable: true }, permissionProgram: { value: input.permissionProgram ?? null, isWritable: false }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player), getAccountMeta(\"permission\", accounts.permission), getAccountMeta(\"permissionProgram\", accounts.permissionProgram), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getSetupTicketPermissionInstructionDataEncoder().encode({}), programAddress } as SetupTicketPermissionInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>);\n}\n\nexport type ParsedSetupTicketPermissionInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nticket: TAccountMetas[0];\ntenant: TAccountMetas[1];\nplayer: TAccountMetas[2];\npermission: TAccountMetas[3];\npermissionProgram: TAccountMetas[4];\nsystemProgram: TAccountMetas[5];\n};\ndata: SetupTicketPermissionInstructionData; };\n\nexport function parseSetupTicketPermissionInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSetupTicketPermissionInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 6) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 6 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount(), permission: getNextAccount(), permissionProgram: getNextAccount(), systemProgram: getNextAccount() }, data: getSetupTicketPermissionInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/duel/programs/duel.d.ts

@@ -0,0 +1,92 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type Address, type ClientWithPayer, type ClientWithRpc, type ClientWithTransactionPlanning, type ClientWithTransactionSending, type GetAccountInfoApi, type GetMultipleAccountsApi, type Instruction, type InstructionWithData, type ReadonlyUint8Array } from '@solana/kit';
+import { type SelfFetchFunctions, type SelfPlanAndSendFunctions } from '@solana/program-client-core';
+import { getMatchTicketCodec, getQueueCodec, getTenantCodec, type MatchTicket, type MatchTicketArgs, type Queue, type QueueArgs, type Tenant, type TenantArgs } from '../accounts';
+import { getCancelTicketInstructionAsync, getCloseTicketInstructionAsync, getCommitTicketsInstruction, getCreateTicketInstructionAsync, getDelegateQueueInstructionAsync, getDelegateTicketInstructionAsync, getFlushMatchesInstruction, getInitializeQueueInstructionAsync, getInitializeTenantInstructionAsync, getJoinQueueInstructionAsync, getProcessUndelegationInstruction, getSetupTicketPermissionInstructionAsync, type CancelTicketAsyncInput, type CloseTicketAsyncInput, type CommitTicketsInput, type CreateTicketAsyncInput, type DelegateQueueAsyncInput, type DelegateTicketAsyncInput, type FlushMatchesInput, type InitializeQueueAsyncInput, type InitializeTenantAsyncInput, type JoinQueueAsyncInput, type ParsedCancelTicketInstruction, type ParsedCloseTicketInstruction, type ParsedCommitTicketsInstruction, type ParsedCreateTicketInstruction, type ParsedDelegateQueueInstruction, type ParsedDelegateTicketInstruction, type ParsedFlushMatchesInstruction, type ParsedInitializeQueueInstruction, type ParsedInitializeTenantInstruction, type ParsedJoinQueueInstruction, type ParsedProcessUndelegationInstruction, type ParsedSetupTicketPermissionInstruction, type ProcessUndelegationInput, type SetupTicketPermissionAsyncInput } from '../instructions';
+export declare const DUEL_PROGRAM_ADDRESS: Address<"EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X">;
+export declare enum DuelAccount {
+    MatchTicket = 0,
+    Queue = 1,
+    Tenant = 2
+}
+export declare function identifyDuelAccount(account: {
+    data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): DuelAccount;
+export declare enum DuelInstruction {
+    CancelTicket = 0,
+    CloseTicket = 1,
+    CommitTickets = 2,
+    CreateTicket = 3,
+    DelegateQueue = 4,
+    DelegateTicket = 5,
+    FlushMatches = 6,
+    InitializeQueue = 7,
+    InitializeTenant = 8,
+    JoinQueue = 9,
+    ProcessUndelegation = 10,
+    SetupTicketPermission = 11
+}
+export declare function identifyDuelInstruction(instruction: {
+    data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): DuelInstruction;
+export type ParsedDuelInstruction<TProgram extends string = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'> = {
+    instructionType: DuelInstruction.CancelTicket;
+} & ParsedCancelTicketInstruction<TProgram> | {
+    instructionType: DuelInstruction.CloseTicket;
+} & ParsedCloseTicketInstruction<TProgram> | {
+    instructionType: DuelInstruction.CommitTickets;
+} & ParsedCommitTicketsInstruction<TProgram> | {
+    instructionType: DuelInstruction.CreateTicket;
+} & ParsedCreateTicketInstruction<TProgram> | {
+    instructionType: DuelInstruction.DelegateQueue;
+} & ParsedDelegateQueueInstruction<TProgram> | {
+    instructionType: DuelInstruction.DelegateTicket;
+} & ParsedDelegateTicketInstruction<TProgram> | {
+    instructionType: DuelInstruction.FlushMatches;
+} & ParsedFlushMatchesInstruction<TProgram> | {
+    instructionType: DuelInstruction.InitializeQueue;
+} & ParsedInitializeQueueInstruction<TProgram> | {
+    instructionType: DuelInstruction.InitializeTenant;
+} & ParsedInitializeTenantInstruction<TProgram> | {
+    instructionType: DuelInstruction.JoinQueue;
+} & ParsedJoinQueueInstruction<TProgram> | {
+    instructionType: DuelInstruction.ProcessUndelegation;
+} & ParsedProcessUndelegationInstruction<TProgram> | {
+    instructionType: DuelInstruction.SetupTicketPermission;
+} & ParsedSetupTicketPermissionInstruction<TProgram>;
+export declare function parseDuelInstruction<TProgram extends string>(instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>): ParsedDuelInstruction<TProgram>;
+export type DuelPlugin = {
+    accounts: DuelPluginAccounts;
+    instructions: DuelPluginInstructions;
+};
+export type DuelPluginAccounts = {
+    matchTicket: ReturnType<typeof getMatchTicketCodec> & SelfFetchFunctions<MatchTicketArgs, MatchTicket>;
+    queue: ReturnType<typeof getQueueCodec> & SelfFetchFunctions<QueueArgs, Queue>;
+    tenant: ReturnType<typeof getTenantCodec> & SelfFetchFunctions<TenantArgs, Tenant>;
+};
+export type DuelPluginInstructions = {
+    cancelTicket: (input: CancelTicketAsyncInput) => ReturnType<typeof getCancelTicketInstructionAsync> & SelfPlanAndSendFunctions;
+    closeTicket: (input: CloseTicketAsyncInput) => ReturnType<typeof getCloseTicketInstructionAsync> & SelfPlanAndSendFunctions;
+    commitTickets: (input: MakeOptional<CommitTicketsInput, "payer">) => ReturnType<typeof getCommitTicketsInstruction> & SelfPlanAndSendFunctions;
+    createTicket: (input: CreateTicketAsyncInput) => ReturnType<typeof getCreateTicketInstructionAsync> & SelfPlanAndSendFunctions;
+    delegateQueue: (input: MakeOptional<DelegateQueueAsyncInput, "payer">) => ReturnType<typeof getDelegateQueueInstructionAsync> & SelfPlanAndSendFunctions;
+    delegateTicket: (input: MakeOptional<DelegateTicketAsyncInput, "payer">) => ReturnType<typeof getDelegateTicketInstructionAsync> & SelfPlanAndSendFunctions;
+    flushMatches: (input: FlushMatchesInput) => ReturnType<typeof getFlushMatchesInstruction> & SelfPlanAndSendFunctions;
+    initializeQueue: (input: InitializeQueueAsyncInput) => ReturnType<typeof getInitializeQueueInstructionAsync> & SelfPlanAndSendFunctions;
+    initializeTenant: (input: InitializeTenantAsyncInput) => ReturnType<typeof getInitializeTenantInstructionAsync> & SelfPlanAndSendFunctions;
+    joinQueue: (input: JoinQueueAsyncInput) => ReturnType<typeof getJoinQueueInstructionAsync> & SelfPlanAndSendFunctions;
+    processUndelegation: (input: MakeOptional<ProcessUndelegationInput, "payer">) => ReturnType<typeof getProcessUndelegationInstruction> & SelfPlanAndSendFunctions;
+    setupTicketPermission: (input: SetupTicketPermissionAsyncInput) => ReturnType<typeof getSetupTicketPermissionInstructionAsync> & SelfPlanAndSendFunctions;
+};
+export type DuelPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending;
+export declare function duelProgram(): <T extends DuelPluginRequirements>(client: T) => T & {
+    duel: DuelPlugin;
+};
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export {};

package/dist/generated/duel/programs/duel.js

@@ -0,0 +1,146 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { assertIsInstructionWithAccounts, containsBytes, fixEncoderSize, getBytesEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError } from '@solana/kit';
+import { addSelfFetchFunctions, addSelfPlanAndSendFunctions } from '@solana/program-client-core';
+import { getMatchTicketCodec, getQueueCodec, getTenantCodec } from '../accounts';
+import { getCancelTicketInstructionAsync, getCloseTicketInstructionAsync, getCommitTicketsInstruction, getCreateTicketInstructionAsync, getDelegateQueueInstructionAsync, getDelegateTicketInstructionAsync, getFlushMatchesInstruction, getInitializeQueueInstructionAsync, getInitializeTenantInstructionAsync, getJoinQueueInstructionAsync, getProcessUndelegationInstruction, getSetupTicketPermissionInstructionAsync, parseCancelTicketInstruction, parseCloseTicketInstruction, parseCommitTicketsInstruction, parseCreateTicketInstruction, parseDelegateQueueInstruction, parseDelegateTicketInstruction, parseFlushMatchesInstruction, parseInitializeQueueInstruction, parseInitializeTenantInstruction, parseJoinQueueInstruction, parseProcessUndelegationInstruction, parseSetupTicketPermissionInstruction } from '../instructions';
+export const DUEL_PROGRAM_ADDRESS = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X';
+export var DuelAccount;
+(function (DuelAccount) {
+    DuelAccount[DuelAccount["MatchTicket"] = 0] = "MatchTicket";
+    DuelAccount[DuelAccount["Queue"] = 1] = "Queue";
+    DuelAccount[DuelAccount["Tenant"] = 2] = "Tenant";
+})(DuelAccount || (DuelAccount = {}));
+export function identifyDuelAccount(account) {
+    const data = 'data' in account ? account.data : account;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([11, 131, 4, 157, 207, 79, 126, 5])), 0)) {
+        return DuelAccount.MatchTicket;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([204, 167, 6, 247, 20, 33, 2, 188])), 0)) {
+        return DuelAccount.Queue;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([61, 43, 215, 51, 232, 242, 209, 170])), 0)) {
+        return DuelAccount.Tenant;
+    }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, { accountData: data, programName: "duel" });
+}
+export var DuelInstruction;
+(function (DuelInstruction) {
+    DuelInstruction[DuelInstruction["CancelTicket"] = 0] = "CancelTicket";
+    DuelInstruction[DuelInstruction["CloseTicket"] = 1] = "CloseTicket";
+    DuelInstruction[DuelInstruction["CommitTickets"] = 2] = "CommitTickets";
+    DuelInstruction[DuelInstruction["CreateTicket"] = 3] = "CreateTicket";
+    DuelInstruction[DuelInstruction["DelegateQueue"] = 4] = "DelegateQueue";
+    DuelInstruction[DuelInstruction["DelegateTicket"] = 5] = "DelegateTicket";
+    DuelInstruction[DuelInstruction["FlushMatches"] = 6] = "FlushMatches";
+    DuelInstruction[DuelInstruction["InitializeQueue"] = 7] = "InitializeQueue";
+    DuelInstruction[DuelInstruction["InitializeTenant"] = 8] = "InitializeTenant";
+    DuelInstruction[DuelInstruction["JoinQueue"] = 9] = "JoinQueue";
+    DuelInstruction[DuelInstruction["ProcessUndelegation"] = 10] = "ProcessUndelegation";
+    DuelInstruction[DuelInstruction["SetupTicketPermission"] = 11] = "SetupTicketPermission";
+})(DuelInstruction || (DuelInstruction = {}));
+export function identifyDuelInstruction(instruction) {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([216, 28, 247, 206, 195, 171, 100, 143])), 0)) {
+        return DuelInstruction.CancelTicket;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([66, 209, 114, 197, 75, 27, 182, 117])), 0)) {
+        return DuelInstruction.CloseTicket;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([245, 199, 81, 0, 62, 133, 18, 22])), 0)) {
+        return DuelInstruction.CommitTickets;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([16, 178, 122, 25, 213, 85, 96, 129])), 0)) {
+        return DuelInstruction.CreateTicket;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([31, 200, 139, 125, 93, 239, 83, 87])), 0)) {
+        return DuelInstruction.DelegateQueue;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([195, 3, 78, 64, 128, 235, 209, 171])), 0)) {
+        return DuelInstruction.DelegateTicket;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([49, 148, 163, 71, 77, 63, 197, 76])), 0)) {
+        return DuelInstruction.FlushMatches;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([174, 102, 132, 232, 90, 202, 27, 20])), 0)) {
+        return DuelInstruction.InitializeQueue;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([94, 120, 34, 186, 57, 167, 241, 206])), 0)) {
+        return DuelInstruction.InitializeTenant;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([157, 115, 48, 109, 65, 86, 203, 238])), 0)) {
+        return DuelInstruction.JoinQueue;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167])), 0)) {
+        return DuelInstruction.ProcessUndelegation;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([164, 29, 7, 235, 183, 223, 11, 85])), 0)) {
+        return DuelInstruction.SetupTicketPermission;
+    }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, { instructionData: data, programName: "duel" });
+}
+export function parseDuelInstruction(instruction) {
+    const instructionType = identifyDuelInstruction(instruction);
+    switch (instructionType) {
+        case DuelInstruction.CancelTicket: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.CancelTicket, ...parseCancelTicketInstruction(instruction) };
+        }
+        case DuelInstruction.CloseTicket: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.CloseTicket, ...parseCloseTicketInstruction(instruction) };
+        }
+        case DuelInstruction.CommitTickets: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.CommitTickets, ...parseCommitTicketsInstruction(instruction) };
+        }
+        case DuelInstruction.CreateTicket: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.CreateTicket, ...parseCreateTicketInstruction(instruction) };
+        }
+        case DuelInstruction.DelegateQueue: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.DelegateQueue, ...parseDelegateQueueInstruction(instruction) };
+        }
+        case DuelInstruction.DelegateTicket: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.DelegateTicket, ...parseDelegateTicketInstruction(instruction) };
+        }
+        case DuelInstruction.FlushMatches: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.FlushMatches, ...parseFlushMatchesInstruction(instruction) };
+        }
+        case DuelInstruction.InitializeQueue: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.InitializeQueue, ...parseInitializeQueueInstruction(instruction) };
+        }
+        case DuelInstruction.InitializeTenant: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.InitializeTenant, ...parseInitializeTenantInstruction(instruction) };
+        }
+        case DuelInstruction.JoinQueue: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.JoinQueue, ...parseJoinQueueInstruction(instruction) };
+        }
+        case DuelInstruction.ProcessUndelegation: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.ProcessUndelegation, ...parseProcessUndelegationInstruction(instruction) };
+        }
+        case DuelInstruction.SetupTicketPermission: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: DuelInstruction.SetupTicketPermission, ...parseSetupTicketPermissionInstruction(instruction) };
+        }
+        default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, { instructionType: instructionType, programName: "duel" });
+    }
+}
+export function duelProgram() {
+    return (client) => {
+        return { ...client, duel: { accounts: { matchTicket: addSelfFetchFunctions(client, getMatchTicketCodec()), queue: addSelfFetchFunctions(client, getQueueCodec()), tenant: addSelfFetchFunctions(client, getTenantCodec()) }, instructions: { cancelTicket: input => addSelfPlanAndSendFunctions(client, getCancelTicketInstructionAsync(input)), closeTicket: input => addSelfPlanAndSendFunctions(client, getCloseTicketInstructionAsync(input)), commitTickets: input => addSelfPlanAndSendFunctions(client, getCommitTicketsInstruction({ ...input, payer: input.payer ?? client.payer })), createTicket: input => addSelfPlanAndSendFunctions(client, getCreateTicketInstructionAsync(input)), delegateQueue: input => addSelfPlanAndSendFunctions(client, getDelegateQueueInstructionAsync({ ...input, payer: input.payer ?? client.payer })), delegateTicket: input => addSelfPlanAndSendFunctions(client, getDelegateTicketInstructionAsync({ ...input, payer: input.payer ?? client.payer })), flushMatches: input => addSelfPlanAndSendFunctions(client, getFlushMatchesInstruction(input)), initializeQueue: input => addSelfPlanAndSendFunctions(client, getInitializeQueueInstructionAsync(input)), initializeTenant: input => addSelfPlanAndSendFunctions(client, getInitializeTenantInstructionAsync(input)), joinQueue: input => addSelfPlanAndSendFunctions(client, getJoinQueueInstructionAsync(input)), processUndelegation: input => addSelfPlanAndSendFunctions(client, getProcessUndelegationInstruction({ ...input, payer: input.payer ?? client.payer.address })), setupTicketPermission: input => addSelfPlanAndSendFunctions(client, getSetupTicketPermissionInstructionAsync(input)) } } };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"duel.js","sourceRoot":"","sources":["../../../../src/generated/duel/programs/duel.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { assertIsInstructionWithAccounts, containsBytes, fixEncoderSize, getBytesEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError, type Address, type ClientWithPayer, type ClientWithRpc, type ClientWithTransactionPlanning, type ClientWithTransactionSending, type GetAccountInfoApi, type GetMultipleAccountsApi, type Instruction, type InstructionWithData, type ReadonlyUint8Array } from '@solana/kit';\nimport { addSelfFetchFunctions, addSelfPlanAndSendFunctions, type SelfFetchFunctions, type SelfPlanAndSendFunctions } from '@solana/program-client-core';\nimport { getMatchTicketCodec, getQueueCodec, getTenantCodec, type MatchTicket, type MatchTicketArgs, type Queue, type QueueArgs, type Tenant, type TenantArgs } from '../accounts';\nimport { getCancelTicketInstructionAsync, getCloseTicketInstructionAsync, getCommitTicketsInstruction, getCreateTicketInstructionAsync, getDelegateQueueInstructionAsync, getDelegateTicketInstructionAsync, getFlushMatchesInstruction, getInitializeQueueInstructionAsync, getInitializeTenantInstructionAsync, getJoinQueueInstructionAsync, getProcessUndelegationInstruction, getSetupTicketPermissionInstructionAsync, parseCancelTicketInstruction, parseCloseTicketInstruction, parseCommitTicketsInstruction, parseCreateTicketInstruction, parseDelegateQueueInstruction, parseDelegateTicketInstruction, parseFlushMatchesInstruction, parseInitializeQueueInstruction, parseInitializeTenantInstruction, parseJoinQueueInstruction, parseProcessUndelegationInstruction, parseSetupTicketPermissionInstruction, type CancelTicketAsyncInput, type CloseTicketAsyncInput, type CommitTicketsInput, type CreateTicketAsyncInput, type DelegateQueueAsyncInput, type DelegateTicketAsyncInput, type FlushMatchesInput, type InitializeQueueAsyncInput, type InitializeTenantAsyncInput, type JoinQueueAsyncInput, type ParsedCancelTicketInstruction, type ParsedCloseTicketInstruction, type ParsedCommitTicketsInstruction, type ParsedCreateTicketInstruction, type ParsedDelegateQueueInstruction, type ParsedDelegateTicketInstruction, type ParsedFlushMatchesInstruction, type ParsedInitializeQueueInstruction, type ParsedInitializeTenantInstruction, type ParsedJoinQueueInstruction, type ParsedProcessUndelegationInstruction, type ParsedSetupTicketPermissionInstruction, type ProcessUndelegationInput, type SetupTicketPermissionAsyncInput } from '../instructions';\n\nexport const DUEL_PROGRAM_ADDRESS = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X' as Address<'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'>;\n\nexport enum DuelAccount { MatchTicket, Queue, Tenant }\n\nexport function identifyDuelAccount(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): DuelAccount {\n    const data = 'data' in account ? account.data : account;\n    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([11, 131, 4, 157, 207, 79, 126, 5])), 0)) { return DuelAccount.MatchTicket; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([204, 167, 6, 247, 20, 33, 2, 188])), 0)) { return DuelAccount.Queue; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([61, 43, 215, 51, 232, 242, 209, 170])), 0)) { return DuelAccount.Tenant; }\n    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, { accountData: data, programName: \"duel\" });\n}\n\nexport enum DuelInstruction { CancelTicket, CloseTicket, CommitTickets, CreateTicket, DelegateQueue, DelegateTicket, FlushMatches, InitializeQueue, InitializeTenant, JoinQueue, ProcessUndelegation, SetupTicketPermission }\n\nexport function identifyDuelInstruction(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): DuelInstruction {\n    const data = 'data' in instruction ? instruction.data : instruction;\n    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([216, 28, 247, 206, 195, 171, 100, 143])), 0)) { return DuelInstruction.CancelTicket; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([66, 209, 114, 197, 75, 27, 182, 117])), 0)) { return DuelInstruction.CloseTicket; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([245, 199, 81, 0, 62, 133, 18, 22])), 0)) { return DuelInstruction.CommitTickets; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([16, 178, 122, 25, 213, 85, 96, 129])), 0)) { return DuelInstruction.CreateTicket; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([31, 200, 139, 125, 93, 239, 83, 87])), 0)) { return DuelInstruction.DelegateQueue; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([195, 3, 78, 64, 128, 235, 209, 171])), 0)) { return DuelInstruction.DelegateTicket; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([49, 148, 163, 71, 77, 63, 197, 76])), 0)) { return DuelInstruction.FlushMatches; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([174, 102, 132, 232, 90, 202, 27, 20])), 0)) { return DuelInstruction.InitializeQueue; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([94, 120, 34, 186, 57, 167, 241, 206])), 0)) { return DuelInstruction.InitializeTenant; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([157, 115, 48, 109, 65, 86, 203, 238])), 0)) { return DuelInstruction.JoinQueue; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167])), 0)) { return DuelInstruction.ProcessUndelegation; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([164, 29, 7, 235, 183, 223, 11, 85])), 0)) { return DuelInstruction.SetupTicketPermission; }\n    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, { instructionData: data, programName: \"duel\" });\n}\n\nexport type ParsedDuelInstruction<TProgram extends string = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'> =\n| { instructionType: DuelInstruction.CancelTicket } & ParsedCancelTicketInstruction<TProgram>\n| { instructionType: DuelInstruction.CloseTicket } & ParsedCloseTicketInstruction<TProgram>\n| { instructionType: DuelInstruction.CommitTickets } & ParsedCommitTicketsInstruction<TProgram>\n| { instructionType: DuelInstruction.CreateTicket } & ParsedCreateTicketInstruction<TProgram>\n| { instructionType: DuelInstruction.DelegateQueue } & ParsedDelegateQueueInstruction<TProgram>\n| { instructionType: DuelInstruction.DelegateTicket } & ParsedDelegateTicketInstruction<TProgram>\n| { instructionType: DuelInstruction.FlushMatches } & ParsedFlushMatchesInstruction<TProgram>\n| { instructionType: DuelInstruction.InitializeQueue } & ParsedInitializeQueueInstruction<TProgram>\n| { instructionType: DuelInstruction.InitializeTenant } & ParsedInitializeTenantInstruction<TProgram>\n| { instructionType: DuelInstruction.JoinQueue } & ParsedJoinQueueInstruction<TProgram>\n| { instructionType: DuelInstruction.ProcessUndelegation } & ParsedProcessUndelegationInstruction<TProgram>\n| { instructionType: DuelInstruction.SetupTicketPermission } & ParsedSetupTicketPermissionInstruction<TProgram>\n\n\n        export function parseDuelInstruction<TProgram extends string>(\n            instruction: Instruction<TProgram> \n                & InstructionWithData<ReadonlyUint8Array>\n        ): ParsedDuelInstruction<TProgram> {\n            const instructionType = identifyDuelInstruction(instruction);\n            switch (instructionType) {\n                case DuelInstruction.CancelTicket: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.CancelTicket, ...parseCancelTicketInstruction(instruction) }; }\ncase DuelInstruction.CloseTicket: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.CloseTicket, ...parseCloseTicketInstruction(instruction) }; }\ncase DuelInstruction.CommitTickets: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.CommitTickets, ...parseCommitTicketsInstruction(instruction) }; }\ncase DuelInstruction.CreateTicket: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.CreateTicket, ...parseCreateTicketInstruction(instruction) }; }\ncase DuelInstruction.DelegateQueue: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.DelegateQueue, ...parseDelegateQueueInstruction(instruction) }; }\ncase DuelInstruction.DelegateTicket: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.DelegateTicket, ...parseDelegateTicketInstruction(instruction) }; }\ncase DuelInstruction.FlushMatches: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.FlushMatches, ...parseFlushMatchesInstruction(instruction) }; }\ncase DuelInstruction.InitializeQueue: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.InitializeQueue, ...parseInitializeQueueInstruction(instruction) }; }\ncase DuelInstruction.InitializeTenant: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.InitializeTenant, ...parseInitializeTenantInstruction(instruction) }; }\ncase DuelInstruction.JoinQueue: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.JoinQueue, ...parseJoinQueueInstruction(instruction) }; }\ncase DuelInstruction.ProcessUndelegation: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.ProcessUndelegation, ...parseProcessUndelegationInstruction(instruction) }; }\ncase DuelInstruction.SetupTicketPermission: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: DuelInstruction.SetupTicketPermission, ...parseSetupTicketPermissionInstruction(instruction) }; }\n                default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, { instructionType: instructionType as string, programName: \"duel\" });\n            }\n        }\n\nexport type DuelPlugin = { accounts: DuelPluginAccounts; instructions: DuelPluginInstructions; }\n\nexport type DuelPluginAccounts = { matchTicket: ReturnType<typeof getMatchTicketCodec> & SelfFetchFunctions<MatchTicketArgs, MatchTicket>; queue: ReturnType<typeof getQueueCodec> & SelfFetchFunctions<QueueArgs, Queue>; tenant: ReturnType<typeof getTenantCodec> & SelfFetchFunctions<TenantArgs, Tenant>; }\n\nexport type DuelPluginInstructions = { cancelTicket: (input: CancelTicketAsyncInput) => ReturnType<typeof getCancelTicketInstructionAsync> & SelfPlanAndSendFunctions; closeTicket: (input: CloseTicketAsyncInput) => ReturnType<typeof getCloseTicketInstructionAsync> & SelfPlanAndSendFunctions; commitTickets: (input: MakeOptional<CommitTicketsInput, \"payer\">) => ReturnType<typeof getCommitTicketsInstruction> & SelfPlanAndSendFunctions; createTicket: (input: CreateTicketAsyncInput) => ReturnType<typeof getCreateTicketInstructionAsync> & SelfPlanAndSendFunctions; delegateQueue: (input: MakeOptional<DelegateQueueAsyncInput, \"payer\">) => ReturnType<typeof getDelegateQueueInstructionAsync> & SelfPlanAndSendFunctions; delegateTicket: (input: MakeOptional<DelegateTicketAsyncInput, \"payer\">) => ReturnType<typeof getDelegateTicketInstructionAsync> & SelfPlanAndSendFunctions; flushMatches: (input: FlushMatchesInput) => ReturnType<typeof getFlushMatchesInstruction> & SelfPlanAndSendFunctions; initializeQueue: (input: InitializeQueueAsyncInput) => ReturnType<typeof getInitializeQueueInstructionAsync> & SelfPlanAndSendFunctions; initializeTenant: (input: InitializeTenantAsyncInput) => ReturnType<typeof getInitializeTenantInstructionAsync> & SelfPlanAndSendFunctions; joinQueue: (input: JoinQueueAsyncInput) => ReturnType<typeof getJoinQueueInstructionAsync> & SelfPlanAndSendFunctions; processUndelegation: (input: MakeOptional<ProcessUndelegationInput, \"payer\">) => ReturnType<typeof getProcessUndelegationInstruction> & SelfPlanAndSendFunctions; setupTicketPermission: (input: SetupTicketPermissionAsyncInput) => ReturnType<typeof getSetupTicketPermissionInstructionAsync> & SelfPlanAndSendFunctions; }\n\nexport type DuelPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending\n\nexport function duelProgram() {\n    return <T extends DuelPluginRequirements>(client: T) => {\n        return { ...client, duel: <DuelPlugin>{ accounts: { matchTicket: addSelfFetchFunctions(client, getMatchTicketCodec()), queue: addSelfFetchFunctions(client, getQueueCodec()), tenant: addSelfFetchFunctions(client, getTenantCodec()) }, instructions: { cancelTicket: input => addSelfPlanAndSendFunctions(client, getCancelTicketInstructionAsync(input)), closeTicket: input => addSelfPlanAndSendFunctions(client, getCloseTicketInstructionAsync(input)), commitTickets: input => addSelfPlanAndSendFunctions(client, getCommitTicketsInstruction({ ...input, payer: input.payer ?? client.payer })), createTicket: input => addSelfPlanAndSendFunctions(client, getCreateTicketInstructionAsync(input)), delegateQueue: input => addSelfPlanAndSendFunctions(client, getDelegateQueueInstructionAsync({ ...input, payer: input.payer ?? client.payer })), delegateTicket: input => addSelfPlanAndSendFunctions(client, getDelegateTicketInstructionAsync({ ...input, payer: input.payer ?? client.payer })), flushMatches: input => addSelfPlanAndSendFunctions(client, getFlushMatchesInstruction(input)), initializeQueue: input => addSelfPlanAndSendFunctions(client, getInitializeQueueInstructionAsync(input)), initializeTenant: input => addSelfPlanAndSendFunctions(client, getInitializeTenantInstructionAsync(input)), joinQueue: input => addSelfPlanAndSendFunctions(client, getJoinQueueInstructionAsync(input)), processUndelegation: input => addSelfPlanAndSendFunctions(client, getProcessUndelegationInstruction({ ...input, payer: input.payer ?? client.payer.address })), setupTicketPermission: input => addSelfPlanAndSendFunctions(client, getSetupTicketPermissionInstructionAsync(input)) } } };\n    };\n}\n\ntype MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;"]}

package/dist/generated/duel/programs/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './duel';

package/dist/generated/duel/programs/index.js

@@ -0,0 +1,9 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './duel';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2R1ZWwvcHJvZ3JhbXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRoaXMgY29kZSB3YXMgQVVUT0dFTkVSQVRFRCB1c2luZyB0aGUgQ29kYW1hIGxpYnJhcnkuXG4gKiBQbGVhc2UgRE8gTk9UIEVESVQgVEhJUyBGSUxFLCBpbnN0ZWFkIHVzZSB2aXNpdG9yc1xuICogdG8gYWRkIGZlYXR1cmVzLCB0aGVuIHJlcnVuIENvZGFtYSB0byB1cGRhdGUgaXQuXG4gKlxuICogQHNlZSBodHRwczovL2dpdGh1Yi5jb20vY29kYW1hLWlkbC9jb2RhbWFcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2R1ZWwnOyJdfQ==

package/dist/generated/duel/types/accountType.d.ts

@@ -0,0 +1,25 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type Address, type Codec, type Decoder, type Encoder, type GetDiscriminatedUnionVariant, type GetDiscriminatedUnionVariantContent } from '@solana/kit';
+export type AccountType = {
+    __kind: "Queue";
+    authority: Address;
+} | {
+    __kind: "Ticket";
+    player: Address;
+    tenant: Address;
+};
+export type AccountTypeArgs = AccountType;
+export declare function getAccountTypeEncoder(): Encoder<AccountTypeArgs>;
+export declare function getAccountTypeDecoder(): Decoder<AccountType>;
+export declare function getAccountTypeCodec(): Codec<AccountTypeArgs, AccountType>;
+export declare function accountType(kind: 'Queue', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'Queue'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'Queue'>;
+export declare function accountType(kind: 'Ticket', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'Ticket'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'Ticket'>;
+export declare function isAccountType<K extends AccountType['__kind']>(kind: K, value: AccountType): value is AccountType & {
+    __kind: K;
+};

package/dist/generated/duel/types/accountType.js

@@ -0,0 +1,25 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, getAddressDecoder, getAddressEncoder, getDiscriminatedUnionDecoder, getDiscriminatedUnionEncoder, getStructDecoder, getStructEncoder } from '@solana/kit';
+export function getAccountTypeEncoder() {
+    return getDiscriminatedUnionEncoder([['Queue', getStructEncoder([['authority', getAddressEncoder()]])], ['Ticket', getStructEncoder([['player', getAddressEncoder()], ['tenant', getAddressEncoder()]])]]);
+}
+export function getAccountTypeDecoder() {
+    return getDiscriminatedUnionDecoder([['Queue', getStructDecoder([['authority', getAddressDecoder()]])], ['Ticket', getStructDecoder([['player', getAddressDecoder()], ['tenant', getAddressDecoder()]])]]);
+}
+export function getAccountTypeCodec() {
+    return combineCodec(getAccountTypeEncoder(), getAccountTypeDecoder());
+}
+export function accountType(kind, data) {
+    return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...(data ?? {}) };
+}
+export function isAccountType(kind, value) {
+    return value.__kind === kind;
+}
+;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudFR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2R1ZWwvdHlwZXMvYWNjb3VudFR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFFLFlBQVksRUFBRSxpQkFBaUIsRUFBRSxpQkFBaUIsRUFBRSw0QkFBNEIsRUFBRSw0QkFBNEIsRUFBRSxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFBcUksTUFBTSxhQUFhLENBQUM7QUFNcFQsTUFBTSxVQUFVLHFCQUFxQjtJQUNqQyxPQUFPLDRCQUE0QixDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLFdBQVcsRUFBRSxpQkFBaUIsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxpQkFBaUIsRUFBRSxDQUFDLEVBQUUsQ0FBQyxRQUFRLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUMvTSxDQUFDO0FBRUQsTUFBTSxVQUFVLHFCQUFxQjtJQUNqQyxPQUFPLDRCQUE0QixDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLFdBQVcsRUFBRSxpQkFBaUIsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxpQkFBaUIsRUFBRSxDQUFDLEVBQUUsQ0FBQyxRQUFRLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUMvTSxDQUFDO0FBRUQsTUFBTSxVQUFVLG1CQUFtQjtJQUMvQixPQUFPLFlBQVksQ0FBQyxxQkFBcUIsRUFBRSxFQUFFLHFCQUFxQixFQUFFLENBQUMsQ0FBQztBQUMxRSxDQUFDO0FBS0QsTUFBTSxVQUFVLFdBQVcsQ0FBNEMsSUFBTyxFQUFFLElBQVc7SUFDekYsT0FBTyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsR0FBRyxDQUFDLElBQUksSUFBSSxFQUFFLENBQUMsRUFBRSxDQUFDO0FBQ2xHLENBQUM7QUFFRCxNQUFNLFVBQVUsYUFBYSxDQUFrQyxJQUFPLEVBQUUsS0FBa0I7SUFDeEYsT0FBTyxLQUFLLENBQUMsTUFBTSxLQUFLLElBQUksQ0FBQztBQUMvQixDQUFDO0FBQUEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVGhpcyBjb2RlIHdhcyBBVVRPR0VORVJBVEVEIHVzaW5nIHRoZSBDb2RhbWEgbGlicmFyeS5cbiAqIFBsZWFzZSBETyBOT1QgRURJVCBUSElTIEZJTEUsIGluc3RlYWQgdXNlIHZpc2l0b3JzXG4gKiB0byBhZGQgZmVhdHVyZXMsIHRoZW4gcmVydW4gQ29kYW1hIHRvIHVwZGF0ZSBpdC5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9jb2RhbWEtaWRsL2NvZGFtYVxuICovXG5cbmltcG9ydCB7IGNvbWJpbmVDb2RlYywgZ2V0QWRkcmVzc0RlY29kZXIsIGdldEFkZHJlc3NFbmNvZGVyLCBnZXREaXNjcmltaW5hdGVkVW5pb25EZWNvZGVyLCBnZXREaXNjcmltaW5hdGVkVW5pb25FbmNvZGVyLCBnZXRTdHJ1Y3REZWNvZGVyLCBnZXRTdHJ1Y3RFbmNvZGVyLCB0eXBlIEFkZHJlc3MsIHR5cGUgQ29kZWMsIHR5cGUgRGVjb2RlciwgdHlwZSBFbmNvZGVyLCB0eXBlIEdldERpc2NyaW1pbmF0ZWRVbmlvblZhcmlhbnQsIHR5cGUgR2V0RGlzY3JpbWluYXRlZFVuaW9uVmFyaWFudENvbnRlbnQgfSBmcm9tICdAc29sYW5hL2tpdCc7XG5cbmV4cG9ydCB0eXBlIEFjY291bnRUeXBlID0geyBfX2tpbmQ6IFwiUXVldWVcIiwgYXV0aG9yaXR5OiBBZGRyZXNzOyAgfSB8IHsgX19raW5kOiBcIlRpY2tldFwiLCBwbGF5ZXI6IEFkZHJlc3M7IHRlbmFudDogQWRkcmVzczsgIH07XG5cbmV4cG9ydCB0eXBlIEFjY291bnRUeXBlQXJncyA9IEFjY291bnRUeXBlO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0QWNjb3VudFR5cGVFbmNvZGVyKCk6IEVuY29kZXI8QWNjb3VudFR5cGVBcmdzPiB7XG4gICAgcmV0dXJuIGdldERpc2NyaW1pbmF0ZWRVbmlvbkVuY29kZXIoW1snUXVldWUnLCBnZXRTdHJ1Y3RFbmNvZGVyKFtbJ2F1dGhvcml0eScsIGdldEFkZHJlc3NFbmNvZGVyKCldXSldLCBbJ1RpY2tldCcsIGdldFN0cnVjdEVuY29kZXIoW1sncGxheWVyJywgZ2V0QWRkcmVzc0VuY29kZXIoKV0sIFsndGVuYW50JywgZ2V0QWRkcmVzc0VuY29kZXIoKV1dKV1dKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldEFjY291bnRUeXBlRGVjb2RlcigpOiBEZWNvZGVyPEFjY291bnRUeXBlPiB7XG4gICAgcmV0dXJuIGdldERpc2NyaW1pbmF0ZWRVbmlvbkRlY29kZXIoW1snUXVldWUnLCBnZXRTdHJ1Y3REZWNvZGVyKFtbJ2F1dGhvcml0eScsIGdldEFkZHJlc3NEZWNvZGVyKCldXSldLCBbJ1RpY2tldCcsIGdldFN0cnVjdERlY29kZXIoW1sncGxheWVyJywgZ2V0QWRkcmVzc0RlY29kZXIoKV0sIFsndGVuYW50JywgZ2V0QWRkcmVzc0RlY29kZXIoKV1dKV1dKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldEFjY291bnRUeXBlQ29kZWMoKTogQ29kZWM8QWNjb3VudFR5cGVBcmdzLCBBY2NvdW50VHlwZT4ge1xuICAgIHJldHVybiBjb21iaW5lQ29kZWMoZ2V0QWNjb3VudFR5cGVFbmNvZGVyKCksIGdldEFjY291bnRUeXBlRGVjb2RlcigpKTtcbn1cblxuLy8gRGF0YSBFbnVtIEhlbHBlcnMuXG5leHBvcnQgZnVuY3Rpb24gYWNjb3VudFR5cGUoa2luZDogJ1F1ZXVlJywgZGF0YTogR2V0RGlzY3JpbWluYXRlZFVuaW9uVmFyaWFudENvbnRlbnQ8QWNjb3VudFR5cGVBcmdzLCAnX19raW5kJywgJ1F1ZXVlJz4pOiBHZXREaXNjcmltaW5hdGVkVW5pb25WYXJpYW50PEFjY291bnRUeXBlQXJncywgJ19fa2luZCcsICdRdWV1ZSc+O1xuZXhwb3J0IGZ1bmN0aW9uIGFjY291bnRUeXBlKGtpbmQ6ICdUaWNrZXQnLCBkYXRhOiBHZXREaXNjcmltaW5hdGVkVW5pb25WYXJpYW50Q29udGVudDxBY2NvdW50VHlwZUFyZ3MsICdfX2tpbmQnLCAnVGlja2V0Jz4pOiBHZXREaXNjcmltaW5hdGVkVW5pb25WYXJpYW50PEFjY291bnRUeXBlQXJncywgJ19fa2luZCcsICdUaWNrZXQnPjtcbmV4cG9ydCBmdW5jdGlvbiBhY2NvdW50VHlwZTxLIGV4dGVuZHMgQWNjb3VudFR5cGVBcmdzWydfX2tpbmQnXSwgRGF0YT4oa2luZDogSywgZGF0YT86IERhdGEpIHtcbiAgcmV0dXJuIEFycmF5LmlzQXJyYXkoZGF0YSkgPyB7IF9fa2luZDoga2luZCwgZmllbGRzOiBkYXRhIH0gOiB7IF9fa2luZDoga2luZCwgLi4uKGRhdGEgPz8ge30pIH07XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc0FjY291bnRUeXBlPEsgZXh0ZW5kcyBBY2NvdW50VHlwZVsnX19raW5kJ10+KGtpbmQ6IEssIHZhbHVlOiBBY2NvdW50VHlwZSk6IHZhbHVlIGlzIEFjY291bnRUeXBlICYgeyBfX2tpbmQ6IEsgfSB7XG4gIHJldHVybiB2YWx1ZS5fX2tpbmQgPT09IGtpbmQ7XG59O1xuIl19

package/dist/generated/duel/types/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './accountType';
+export * from './matchEntry';
+export * from './matchFound';
+export * from './pendingMatch';
+export * from './queueEntry';
+export * from './ticketStatus';

package/dist/generated/duel/types/index.js

@@ -0,0 +1,14 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './accountType';
+export * from './matchEntry';
+export * from './matchFound';
+export * from './pendingMatch';
+export * from './queueEntry';
+export * from './ticketStatus';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2R1ZWwvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGlzIGNvZGUgd2FzIEFVVE9HRU5FUkFURUQgdXNpbmcgdGhlIENvZGFtYSBsaWJyYXJ5LlxuICogUGxlYXNlIERPIE5PVCBFRElUIFRISVMgRklMRSwgaW5zdGVhZCB1c2UgdmlzaXRvcnNcbiAqIHRvIGFkZCBmZWF0dXJlcywgdGhlbiByZXJ1biBDb2RhbWEgdG8gdXBkYXRlIGl0LlxuICpcbiAqIEBzZWUgaHR0cHM6Ly9naXRodWIuY29tL2NvZGFtYS1pZGwvY29kYW1hXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9hY2NvdW50VHlwZSc7XG5leHBvcnQgKiBmcm9tICcuL21hdGNoRW50cnknO1xuZXhwb3J0ICogZnJvbSAnLi9tYXRjaEZvdW5kJztcbmV4cG9ydCAqIGZyb20gJy4vcGVuZGluZ01hdGNoJztcbmV4cG9ydCAqIGZyb20gJy4vcXVldWVFbnRyeSc7XG5leHBvcnQgKiBmcm9tICcuL3RpY2tldFN0YXR1cyc7Il19