@codama/renderers-js 1.0.0

package/dist/templates/fragments/accountFetchHelpers.njk

@@ -0,0 +1,43 @@
+export function {{ decodeFunction }}<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<{{ accountType }}, TAddress>;
+export function {{ decodeFunction }}<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<{{ accountType }}, TAddress>;
+export function {{ decodeFunction }}<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<{{ accountType }}, TAddress> | MaybeAccount<{{ accountType }}, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, {{ decoderFunction }});
+}
+
+export async function {{ fetchFunction }}<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<{{ accountType }}, TAddress>> {
+  const maybeAccount = await {{ fetchMaybeFunction }}(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function {{ fetchMaybeFunction }}<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<{{ accountType }}, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return {{ decodeFunction }}(maybeAccount);
+}
+
+export async function {{ fetchAllFunction }}(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<{{ accountType }}>[]> {
+  const maybeAccounts = await {{ fetchAllMaybeFunction }}(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function {{ fetchAllMaybeFunction }}(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<{{ accountType }}>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => {{ decodeFunction }}(maybeAccount));
+}

package/dist/templates/fragments/accountPdaHelpers.njk

@@ -0,0 +1,25 @@
+{% import "macros.njk" as macros %}
+
+export async function {{ fetchFromSeedsFunction }}(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  {% if hasVariableSeeds %}
+    seeds: {{ pdaSeedsType }},
+  {% endif %}
+  config: FetchAccountConfig & { programAddress?: Address } = {},
+): Promise<Account<{{ accountType }}>> {
+  const maybeAccount = await {{ fetchMaybeFromSeedsFunction }}(rpc, {% if hasVariableSeeds %}seeds, {% endif %}config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function {{ fetchMaybeFromSeedsFunction }}(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  {% if hasVariableSeeds %}
+    seeds: {{ pdaSeedsType }},
+  {% endif %}
+  config: FetchAccountConfig & { programAddress?: Address } = {},
+): Promise<MaybeAccount<{{ accountType }}>> {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await {{ findPdaFunction }}({% if hasVariableSeeds %}seeds, {% endif %}{ programAddress });
+  return await {{ fetchMaybeFunction }}(rpc, address, fetchConfig);
+}

package/dist/templates/fragments/accountSizeHelpers.njk

@@ -0,0 +1,3 @@
+export function {{ getSizeFunction }}(): number {
+  return {{ account.size }};
+}

package/dist/templates/fragments/instructionExtraArgs.njk

@@ -0,0 +1,4 @@
+{% import "macros.njk" as macros %}
+
+{{ macros.docblock(docs) }}
+export type {{ looseName }} = {{ manifest.looseType.render }};

package/dist/templates/fragments/instructionFunction.njk

@@ -0,0 +1,62 @@
+{{ inputTypeFragment }}
+
+export {{ 'async' if useAsync }} function {{ functionName }}{{ typeParamsFragment }}(input: {{ inputTypeCallFragment }}, config?: { programAddress?: TProgramAddress } ): {{ getReturnType(instructionTypeFragment) }} {
+  // Program address.
+  const programAddress = config?.programAddress ?? {{ programAddressConstant }};
+
+  {% if hasAccounts %}
+    // Original accounts.
+    const originalAccounts = {
+      {% for account in instruction.accounts %}
+        {{ account.name | camelCase }}: { value: input.{{ account.name | camelCase }} ?? null, isWritable: {{ "true" if account.isWritable else "false" }} },
+      {% endfor %}
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedAccount>;
+  {% endif %}
+
+  {% if hasAnyArgs %}
+    // Original args.
+    const args = { ...input, {{ renamedArgs }} };
+  {% endif %}
+
+  {% if hasResolver %}
+    // Resolver scope.
+    const resolverScope = { programAddress{{ ', accounts' if hasAccounts }}{{ ', args' if hasAnyArgs }} };
+  {% endif %}
+
+  {{ resolvedFragment }}
+
+  {% if hasAccounts %}
+    const getAccountMeta = getAccountMetaFactory(programAddress, '{{ 'omitted' if instruction.optionalAccountStrategy === 'omitted' else 'programId' }}');
+  {% endif %}
+  const instruction = {
+    {%- if hasAccounts -%}
+      accounts: [
+        {% for account in instruction.accounts %}
+          getAccountMeta(accounts.{{ account.name | camelCase }}),
+        {% endfor %}
+        {% if hasRemainingAccounts %}
+          ...remainingAccounts,
+        {% endif %}
+      ]
+      {%- if hasLegacyOptionalAccounts -%}
+        .filter(<T>(x: T | undefined): x is T => x !== undefined)
+      {% endif %}
+      ,
+    {%- elif hasRemainingAccounts -%}
+      accounts: remainingAccounts,
+    {% endif %}
+    programAddress,
+    {% if hasDataArgs %}
+      data: {{ encoderFunction }}.encode(args as {{ argsTypeFragment }}),
+    {% elif hasData %}
+      data: {{ encoderFunction }}.encode({}),
+    {% endif %}
+  } as {{ instructionTypeFragment }};
+
+  {% if hasByteDeltas %}
+    return Object.freeze({ ...instruction, byteDelta });
+  {% else %}
+    return instruction;
+  {% endif %}
+}

package/dist/templates/fragments/instructionInputType.njk

@@ -0,0 +1,16 @@
+{% import "macros.njk" as macros %}
+
+export type {{ instructionInputType }}
+{%- if instruction.accounts.length > 0 -%}
+<
+  {%- for account in instruction.accounts -%}
+    TAccount{{ account.name | pascalCase }} extends string = string,
+  {% endfor %}
+>
+{% endif %}
+= {{ customDataArgumentsFragment }} {
+  {{ accountsFragment -}}
+  {{ dataArgumentsFragment -}}
+  {{ extraArgumentsFragment -}}
+  {{ remainingAccountsFragment }}
+}

package/dist/templates/fragments/instructionParseFunction.njk

@@ -0,0 +1,81 @@
+{% import "macros.njk" as macros %}
+
+export type {{ instructionParsedType }}<
+  TProgram extends string = typeof {{ programAddressConstant }},
+  {% if hasAccounts %}
+    TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
+  {% endif %}
+> = {
+  programAddress: Address<TProgram>;
+  {% if hasAccounts %}
+    accounts: {
+      {% for account in instruction.accounts %}
+        {% if account.docs.length > 0 %}
+          {{ macros.docblock(account.docs) }}
+        {% endif %}
+        {{ account.name | camelCase }}{{ '?' if account.isOptional }}: TAccountMetas[{{ loop.index0 }}]{{ ' | undefined' if account.isOptional }},
+      {% endfor %}
+    };
+  {% endif %}
+  {% if hasData %}
+    data: {{ dataTypeFragment }};
+  {% endif %}
+};
+
+export function {{ instructionParseFunction }}<
+  TProgram extends string,
+  {% if hasAccounts %}
+    TAccountMetas extends readonly IAccountMeta[],
+  {% endif %}
+>(
+  instruction: IInstruction<TProgram>
+    {% if hasAccounts %}
+      & IInstructionWithAccounts<TAccountMetas>
+    {% endif %}
+    {% if hasData %}
+      & IInstructionWithData<Uint8Array>
+    {% endif %}
+): {{ instructionParsedType }}<TProgram {{ ', TAccountMetas' if hasAccounts }}> {
+  {% if hasAccounts %}
+    if (instruction.accounts.length < {{ minimumNumberOfAccounts }}) {
+      // TODO: Coded error.
+      throw new Error('Not enough accounts');
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+      const accountMeta = instruction.accounts![accountIndex]!;
+      accountIndex += 1;
+      return accountMeta;
+    }
+    {% if hasOptionalAccounts and instruction.optionalAccountStrategy === 'programId' %}
+      const getNextOptionalAccount = () => {
+        const accountMeta = getNextAccount();
+        return accountMeta.address === {{ programAddressConstant }} ? undefined : accountMeta;
+      };
+    {% elif hasOptionalAccounts and instruction.optionalAccountStrategy === 'omitted' %}
+      let optionalAccountsRemaining = instruction.accounts.length - {{ minimumNumberOfAccounts }};
+      const getNextOptionalAccount = () => {
+        if (optionalAccountsRemaining === 0) return undefined;
+        optionalAccountsRemaining -= 1;
+        return getNextAccount();
+      };
+    {% endif %}
+  {% endif %}
+  return {
+    programAddress: instruction.programAddress,
+    {% if hasAccounts %}
+      accounts: {
+        {% for account in instruction.accounts %}
+          {% if account.isOptional %}
+            {{ account.name | camelCase }}: getNextOptionalAccount(),
+          {% else %}
+            {{ account.name | camelCase }}: getNextAccount(),
+          {% endif %}
+        {% endfor %}
+      },
+    {% endif %}
+    {% if hasData %}
+      data: {{ decoderFunction }}.decode(instruction.data),
+    {% endif %}
+  };
+}

package/dist/templates/fragments/instructionType.njk

@@ -0,0 +1,18 @@
+{% import "macros.njk" as macros %}
+
+export type {{ instructionType }}<
+  TProgram extends string = typeof {{ programAddressConstant }},
+  {% if hasAccounts %}
+    {{ accountTypeParams }},
+  {% endif %}
+  TRemainingAccounts extends readonly IAccountMeta<string>[] = [],
+> = IInstruction<TProgram>
+  {% if hasData %}
+    & IInstructionWithData<Uint8Array>
+  {% endif %}
+  {% if hasAccounts %}
+    & IInstructionWithAccounts<[{{ accountMetas }}, ...TRemainingAccounts]>
+  {% else %}
+    & IInstructionWithAccounts<TRemainingAccounts>
+  {% endif %}
+;

package/dist/templates/fragments/pdaFunction.njk

@@ -0,0 +1,32 @@
+{% import "macros.njk" as macros %}
+
+{% if hasVariableSeeds %}
+export type {{ pdaSeedsType }} = {
+  {% for seed in seeds %}
+    {% if seed.kind === 'variablePdaSeedNode' %}
+      {{ macros.docblock(seed.docs) }}
+      {{ seed.name | camelCase }}: {{ seed.typeManifest.looseType.render }};
+    {% endif %}
+  {% endfor %}
+}
+{% endif %}
+
+export async function {{ findPdaFunction }}(
+  {% if hasVariableSeeds %}
+    seeds: {{ pdaSeedsType }},
+  {% endif %}
+  config: { programAddress?: Address | undefined } = {},
+): Promise<ProgramDerivedAddress> {
+  const { programAddress = '{{ programAddress }}' as Address<'{{ programAddress }}'> } = config;
+  return await getProgramDerivedAddress({ programAddress, seeds: [
+    {% for seed in seeds %}
+      {% if seed.kind === 'constantPdaSeedNode' and seed.value.kind === 'programIdValueNode' %}
+        getAddressEncoder().encode(programAddress),
+      {% elif seed.kind === 'constantPdaSeedNode' %}
+        {{ seed.typeManifest.encoder.render }}.encode({{ seed.valueManifest.render }}),
+      {% else %}
+        {{ seed.typeManifest.encoder.render }}.encode(seeds.{{ seed.name | camelCase }}),
+      {% endif %}
+    {% endfor %}
+  ]});
+}

package/dist/templates/fragments/program.njk

@@ -0,0 +1,3 @@
+{% import "macros.njk" as macros %}
+
+export const {{ programAddressConstant }} = '{{ program.publicKey }}' as Address<'{{ program.publicKey }}'>;

package/dist/templates/fragments/programErrors.njk

@@ -0,0 +1,36 @@
+{% import "macros.njk" as macros %}
+
+{% for error in errors | sort(false, false, 'code') %}
+  {{ macros.docblock(error.docs) }}
+  export const {{ getProgramErrorConstant(error.name) }} = 0x{{ error.code.toString(16) }}, // {{ error.code }}
+{% endfor %}
+
+export type {{ programErrorUnion }} =
+  {% for error in errors | sort(false, false, 'name') %}
+    | typeof {{ getProgramErrorConstant(error.name) }}
+  {% endfor %};
+
+let {{ programErrorMessagesMap }}: Record<{{ programErrorUnion }}, string> | undefined;
+if (process.env.NODE_ENV !== 'production') {
+  {{ programErrorMessagesMap }} = {
+    {% for error in errors | sort(false, false, 'name') %}
+      [{{ getProgramErrorConstant(error.name) }}]: `{{ error.message }}`,
+    {% endfor %}
+  };
+}
+
+export function {{ programGetErrorMessageFunction }}(code: {{ programErrorUnion }}): string {
+  if (process.env.NODE_ENV !== 'production') {
+    return ({{ programErrorMessagesMap }} as Record<{{ programErrorUnion }}, string>)[code];
+  }
+
+  return 'Error message not available in production bundles.';
+}
+
+export function {{ programIsErrorFunction }}<TProgramErrorCode extends {{ programErrorUnion }}>(
+    error: unknown,
+    transactionMessage: { instructions: Record<number, { programAddress: Address }> },
+    code?: TProgramErrorCode,
+): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> & Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
+  return isProgramError<TProgramErrorCode>(error, transactionMessage, {{ programAddressConstant }}, code);
+}

package/dist/templates/fragments/type.njk

@@ -0,0 +1,12 @@
+{% import "macros.njk" as macros %}
+
+{{ macros.docblock(docs) }}
+{% if manifest.isEnum %}
+export enum {{ strictName }} {{ manifest.strictType.render }};
+
+export type {{ looseName }} = {{ strictName }};
+{% else %}
+export type {{ strictName }} = {{ manifest.strictType.render }};
+
+export type {{ looseName }} = {{ manifest.looseType.render if manifest.strictType.render != manifest.looseType.render else strictName }};
+{% endif %}

package/dist/templates/fragments/typeCodec.njk

@@ -0,0 +1,6 @@
+{% import "macros.njk" as macros %}
+
+{{ macros.docblock(docs) }}
+export function {{ codecFunction }}(): Codec<{{ looseName }}, {{ strictName }}> {
+  return combineCodec({{ encoderFunction }}(), {{ decoderFunction }}());
+}

package/dist/templates/fragments/typeDecoder.njk

@@ -0,0 +1,6 @@
+{% import "macros.njk" as macros %}
+
+{{ macros.docblock(docs) }}
+export function {{ decoderFunction }}(): Decoder<{{ strictName }}> {
+  return {{ manifest.decoder.render }};
+}

package/dist/templates/fragments/typeDiscriminatedUnionHelpers.njk

@@ -0,0 +1,23 @@
+// Data Enum Helpers.
+{% for variant in typeNode.variants %}
+  {% if variant.kind === 'enumStructVariantTypeNode' %}
+    export function {{ discriminatedUnionFunction }}(kind: '{{ getVariant(variant.name) }}', data: GetDiscriminatedUnionVariantContent<{{ looseName }}, '{{ discriminatedUnionDiscriminator }}', '{{ getVariant(variant.name) }}'>): GetDiscriminatedUnionVariant<{{ looseName }}, '{{ discriminatedUnionDiscriminator }}', '{{ getVariant(variant.name) }}'>;
+  {% elif variant.kind === 'enumTupleVariantTypeNode' %}
+    export function {{ discriminatedUnionFunction }}(kind: '{{ getVariant(variant.name) }}', data: GetDiscriminatedUnionVariantContent<{{ looseName }}, '{{ discriminatedUnionDiscriminator }}', '{{ getVariant(variant.name) }}'>['fields']): GetDiscriminatedUnionVariant<{{ looseName }}, '{{ discriminatedUnionDiscriminator }}', '{{ getVariant(variant.name) }}'>;
+  {% else %}
+    export function {{ discriminatedUnionFunction }}(kind: '{{ getVariant(variant.name) }}'): GetDiscriminatedUnionVariant<{{ looseName }}, '{{ discriminatedUnionDiscriminator }}', '{{ getVariant(variant.name) }}'>;
+  {% endif %}
+{% endfor %}
+export function {{ discriminatedUnionFunction }}<K extends {{ looseName }}['{{ discriminatedUnionDiscriminator }}'], Data>(
+  kind: K,
+  data?: Data,
+) {
+  return Array.isArray(data) ? { {{ discriminatedUnionDiscriminator }}: kind, fields: data } : { {{ discriminatedUnionDiscriminator }}: kind, ...(data ?? {}) };
+}
+
+export function {{ isDiscriminatedUnionFunction }}<K extends {{ strictName }}['{{ discriminatedUnionDiscriminator }}']>(
+  kind: K,
+  value: {{ strictName }},
+): value is {{ strictName }} & { {{ discriminatedUnionDiscriminator }}: K } {
+  return value.{{ discriminatedUnionDiscriminator }} === kind;
+};

package/dist/templates/fragments/typeEncoder.njk

@@ -0,0 +1,6 @@
+{% import "macros.njk" as macros %}
+
+{{ macros.docblock(docs) }}
+export function {{ encoderFunction }}(): Encoder<{{ looseName }}> {
+  return {{ manifest.encoder.render }};
+}

package/dist/templates/layout.njk

@@ -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
+ */
+
+{% block main %}{% endblock %}

package/dist/templates/macros.njk

@@ -0,0 +1,12 @@
+{# Write a docblock from an array of strings. #}
+{% macro docblock(docs) %}
+{%- if docs.length === 1 -%}
+/** {{ docs[0] }} */
+{%- elif docs.length > 1 -%}
+/**
+{% for doc in docs %}
+ * {{ doc }}
+{% endfor %}
+ */
+{% endif %}
+{% endmacro %}

package/dist/templates/pages/accountsIndex.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% for account in accountsToExport | sort(false, false, 'name') %}
+export * from './{{ account.name | camelCase }}';
+{% else %}
+export default {};
+{% endfor %}
+{% endblock %}

package/dist/templates/pages/accountsPage.njk

@@ -0,0 +1,12 @@
+{% extends "layout.njk" %}
+{% import "macros.njk" as macros %}
+
+{% block main %}
+{{ imports }}
+
+{{ accountDiscriminatorConstantsFragment }}
+{{ accountTypeFragment }}
+{{ accountFetchHelpersFragment }}
+{{ accountSizeHelpersFragment }}
+{{ accountPdaHelpersFragment }}
+{% endblock %}

package/dist/templates/pages/definedTypesIndex.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% for definedType in definedTypesToExport | sort(false, false, 'name') %}
+export * from './{{ definedType.name | camelCase }}';
+{% else %}
+export default {};
+{% endfor %}
+{% endblock %}

package/dist/templates/pages/definedTypesPage.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+{% import "macros.njk" as macros %}
+
+{% block main %}
+{{ imports }}
+
+{{ typeWithCodecFragment }}
+{{ typeDiscriminatedUnionHelpersFragment }}
+{% endblock %}

package/dist/templates/pages/errorsIndex.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% for program in programsWithErrorsToExport | sort(false, false, 'name') %}
+export * from './{{ program.name | camelCase }}';
+{% else %}
+export default {};
+{% endfor %}
+{% endblock %}

package/dist/templates/pages/errorsPage.njk

@@ -0,0 +1,8 @@
+{% extends "layout.njk" %}
+{% import "macros.njk" as macros %}
+
+{% block main %}
+{{ imports }}
+
+{{ programErrorsFragment }}
+{% endblock %}

package/dist/templates/pages/instructionsIndex.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% for instruction in instructionsToExport | sort(false, false, 'name') %}
+export * from './{{ instruction.name | camelCase }}';
+{% else %}
+export default {};
+{% endfor %}
+{% endblock %}

package/dist/templates/pages/instructionsPage.njk

@@ -0,0 +1,14 @@
+{% extends "layout.njk" %}
+{% import "macros.njk" as macros %}
+
+{% block main %}
+{{ imports }}
+
+{{ instructionDiscriminatorConstantsFragment }}
+{{ instructionTypeFragment }}
+{{ instructionDataFragment }}
+{{ instructionExtraArgsFragment }}
+{{ instructionFunctionAsyncFragment }}
+{{ instructionFunctionSyncFragment }}
+{{ instructionParseFunctionFragment }}
+{% endblock %}

package/dist/templates/pages/pdasIndex.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% for pda in pdasToExport | sort(false, false, 'name') %}
+export * from './{{ pda.name | camelCase }}';
+{% else %}
+export default {};
+{% endfor %}
+{% endblock %}

package/dist/templates/pages/pdasPage.njk

@@ -0,0 +1,8 @@
+{% extends "layout.njk" %}
+{% import "macros.njk" as macros %}
+
+{% block main %}
+{{ imports }}
+
+{{ pdaFunctionFragment }}
+{% endblock %}

package/dist/templates/pages/programsIndex.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% for program in programsToExport | sort(false, false, 'name') %}
+export * from './{{ program.name | camelCase }}';
+{% else %}
+export default {};
+{% endfor %}
+{% endblock %}

package/dist/templates/pages/programsPage.njk

@@ -0,0 +1,10 @@
+{% extends "layout.njk" %}
+{% import "macros.njk" as macros %}
+
+{% block main %}
+{{ imports }}
+
+{{ programFragment }}
+{{ programAccountsFragment }}
+{{ programInstructionsFragment }}
+{% endblock %}

package/dist/templates/pages/rootIndex.njk

@@ -0,0 +1,26 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% if hasAnythingToExport %}
+  {% if accountsToExport.length > 0 %}
+    export * from './accounts';
+  {% endif %}
+  {% if programsWithErrorsToExport.length > 0 %}
+    export * from './errors';
+  {% endif %}
+  {% if instructionsToExport.length > 0 %}
+    export * from './instructions';
+  {% endif %}
+  {% if pdasToExport.length > 0 %}
+    export * from './pdas';
+  {% endif %}
+  {% if programsToExport.length > 0 %}
+    export * from './programs';
+  {% endif %}
+  {% if definedTypesToExport.length > 0 %}
+    export * from './types';
+  {% endif %}
+{% else %}
+export default {};
+{% endif %}
+{% endblock %}