@metaplex-foundation/kinobi 0.0.1

package/dist/types/nodes/TypeStructFieldNode.d.ts

@@ -0,0 +1,24 @@
+import type { IdlTypeStructField } from '../idl';
+import type { Visitable, Visitor } from '../visitors';
+import type { Node } from './Node';
+import { TypeNode } from './TypeNode';
+import { ValueNode } from './ValueNode';
+export type TypeStructFieldNodeMetadata = {
+    name: string;
+    docs: string[];
+    defaultsTo: {
+        strategy: 'optional' | 'omitted';
+        value: ValueNode;
+    } | null;
+};
+export declare class TypeStructFieldNode implements Visitable {
+    readonly nodeClass: "TypeStructFieldNode";
+    readonly metadata: TypeStructFieldNodeMetadata;
+    readonly type: TypeNode;
+    constructor(metadata: TypeStructFieldNodeMetadata, type: TypeNode);
+    static fromIdl(idl: IdlTypeStructField): TypeStructFieldNode;
+    accept<T>(visitor: Visitor<T>): T;
+    get name(): string;
+}
+export declare function isTypeStructFieldNode(node: Node | null): node is TypeStructFieldNode;
+export declare function assertTypeStructFieldNode(node: Node | null): asserts node is TypeStructFieldNode;

package/dist/types/nodes/TypeStructNode.d.ts

@@ -0,0 +1,14 @@
+import type { IdlTypeStruct } from '../idl';
+import type { Visitable, Visitor } from '../visitors';
+import type { Node } from './Node';
+import { TypeStructFieldNode } from './TypeStructFieldNode';
+export declare class TypeStructNode implements Visitable {
+    readonly nodeClass: "TypeStructNode";
+    readonly name: string;
+    readonly fields: TypeStructFieldNode[];
+    constructor(name: string, fields: TypeStructFieldNode[]);
+    static fromIdl(idl: IdlTypeStruct): TypeStructNode;
+    accept<T>(visitor: Visitor<T>): T;
+}
+export declare function isTypeStructNode(node: Node | null): node is TypeStructNode;
+export declare function assertTypeStructNode(node: Node | null): asserts node is TypeStructNode;

package/dist/types/nodes/TypeTupleNode.d.ts

@@ -0,0 +1,13 @@
+import type { IdlTypeTuple } from '../idl';
+import type { Visitable, Visitor } from '../visitors';
+import { TypeNode } from './TypeNode';
+import type { Node } from './Node';
+export declare class TypeTupleNode implements Visitable {
+    readonly nodeClass: "TypeTupleNode";
+    readonly itemTypes: TypeNode[];
+    constructor(itemTypes: TypeNode[]);
+    static fromIdl(idl: IdlTypeTuple): TypeTupleNode;
+    accept<T>(visitor: Visitor<T>): T;
+}
+export declare function isTypeTupleNode(node: Node | null): node is TypeTupleNode;
+export declare function assertTypeTupleNode(node: Node | null): asserts node is TypeTupleNode;

package/dist/types/nodes/TypeVecNode.d.ts

@@ -0,0 +1,13 @@
+import type { IdlTypeVec } from '../idl';
+import type { Visitable, Visitor } from '../visitors';
+import { TypeNode } from './TypeNode';
+import type { Node } from './Node';
+export declare class TypeVecNode implements Visitable {
+    readonly nodeClass: "TypeVecNode";
+    readonly itemType: TypeNode;
+    constructor(itemType: TypeNode);
+    static fromIdl(idl: IdlTypeVec): TypeVecNode;
+    accept<T>(visitor: Visitor<T>): T;
+}
+export declare function isTypeVecNode(node: Node | null): node is TypeVecNode;
+export declare function assertTypeVecNode(node: Node | null): asserts node is TypeVecNode;

package/dist/types/nodes/ValueNode.d.ts

@@ -0,0 +1,59 @@
+import { Dependency } from '../visitors';
+export type ValueNode = ScalarValueNode | PublicKeyValueNode | ListValueNode | TupleValueNode | SetValueNode | MapValueNode | OptionValueNode | StructValueNode | EnumValueNode;
+export type ScalarValueNode = {
+    __kind: 'number';
+    value: number;
+} | {
+    __kind: 'boolean';
+    value: boolean;
+} | {
+    __kind: 'string';
+    value: string;
+};
+export declare const vScalar: (scalar: number | boolean | string) => ScalarValueNode;
+export type PublicKeyValueNode = {
+    __kind: 'publicKey';
+    value: string;
+};
+export declare const vPublicKey: (value: string) => PublicKeyValueNode;
+export type ListValueNode = {
+    __kind: 'list';
+    values: ValueNode[];
+};
+export declare const vList: (values: ValueNode[]) => ListValueNode;
+export type TupleValueNode = {
+    __kind: 'tuple';
+    values: ValueNode[];
+};
+export declare const vTuple: (values: ValueNode[]) => TupleValueNode;
+export type SetValueNode = {
+    __kind: 'set';
+    values: ValueNode[];
+};
+export declare const vSet: (values: ValueNode[]) => SetValueNode;
+export type MapValueNode = {
+    __kind: 'map';
+    values: [ValueNode, ValueNode][];
+};
+export declare const vMap: (values: [ValueNode, ValueNode][]) => MapValueNode;
+export type OptionValueNode = {
+    __kind: 'optionNone';
+} | {
+    __kind: 'optionSome';
+    value: ValueNode;
+};
+export declare const vNone: () => OptionValueNode;
+export declare const vSome: (value: ValueNode) => OptionValueNode;
+export type StructValueNode = {
+    __kind: 'struct';
+    values: Record<string, ValueNode>;
+};
+export declare const vStruct: (values: Record<string, ValueNode>) => StructValueNode;
+export type EnumValueNode = {
+    __kind: 'enum';
+    enumType: string;
+    variant: string;
+    value: StructValueNode | TupleValueNode | null;
+    dependency: Dependency | null;
+};
+export declare const vEnum: (enumType: string, variant: string, value?: StructValueNode | TupleValueNode | null, dependency?: Dependency | null) => EnumValueNode;

package/dist/types/nodes/index.d.ts

@@ -0,0 +1,25 @@
+export * from './AccountNode';
+export * from './DefinedTypeNode';
+export * from './ErrorNode';
+export * from './InstructionNode';
+export * from './Node';
+export * from './ProgramNode';
+export * from './RootNode';
+export * from './TypeArrayNode';
+export * from './TypeDefinedLinkNode';
+export * from './TypeEnumEmptyVariantNode';
+export * from './TypeEnumNode';
+export * from './TypeEnumStructVariantNode';
+export * from './TypeEnumTupleVariantNode';
+export * from './TypeEnumVariantNode';
+export * from './TypeLeafNode';
+export * from './TypeLeafWrapperNode';
+export * from './TypeMapNode';
+export * from './TypeNode';
+export * from './TypeOptionNode';
+export * from './TypeSetNode';
+export * from './TypeStructNode';
+export * from './TypeStructFieldNode';
+export * from './TypeTupleNode';
+export * from './TypeVecNode';
+export * from './ValueNode';

package/dist/types/renderers/RenderMap.d.ts

@@ -0,0 +1,8 @@
+export declare class RenderMap {
+    protected readonly _map: Map<string, string>;
+    add(relativePath: string, code: string): RenderMap;
+    remove(relativePath: string): RenderMap;
+    mergeWith(...others: RenderMap[]): RenderMap;
+    isEmpty(): boolean;
+    write(path: string): void;
+}

package/dist/types/renderers/WriteRenderMapVisitor.d.ts

@@ -0,0 +1,8 @@
+import { Visitor, BaseDelegateVisitor } from '../visitors';
+import { RenderMap } from './RenderMap';
+export declare class WriteRenderMapVisitor extends BaseDelegateVisitor<RenderMap, void> {
+    readonly visitor: Visitor<RenderMap>;
+    readonly path: string;
+    constructor(visitor: Visitor<RenderMap>, path: string);
+    map(renderMap: RenderMap): void;
+}

package/dist/types/renderers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './js';
+export * from './RenderMap';
+export * from './utils';
+export * from './WriteRenderMapVisitor';

package/dist/types/renderers/js/GetJavaScriptRenderMapVisitor.d.ts

@@ -0,0 +1,34 @@
+import type { ConfigureOptions } from 'nunjucks';
+import { Options as PrettierOptions } from 'prettier';
+import * as nodes from '../../nodes';
+import { Visitor, BaseThrowVisitor, ResolvedInstructionAccount, Dependency } from '../../visitors';
+import { RenderMap } from '../RenderMap';
+import { JavaScriptTypeManifest } from './GetJavaScriptTypeManifestVisitor';
+import { JavaScriptImportMap } from './JavaScriptImportMap';
+export type GetJavaScriptRenderMapOptions = {
+    formatCode?: boolean;
+    prettierOptions?: PrettierOptions;
+    dependencyMap?: Record<Dependency, string>;
+    typeManifestVisitor?: Visitor<JavaScriptTypeManifest> & {
+        registerDefinedTypes?: (definedTypes: nodes.DefinedTypeNode[]) => void;
+    };
+};
+export declare class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
+    readonly options: Required<GetJavaScriptRenderMapOptions>;
+    private program;
+    private availableDefinedTypes;
+    private resolvedInstructionAccountVisitor;
+    constructor(options?: GetJavaScriptRenderMapOptions);
+    visitRoot(root: nodes.RootNode): RenderMap;
+    visitProgram(program: nodes.ProgramNode): RenderMap;
+    visitAccount(account: nodes.AccountNode): RenderMap;
+    visitInstruction(instruction: nodes.InstructionNode): RenderMap;
+    visitDefinedType(definedType: nodes.DefinedTypeNode): RenderMap;
+    get typeManifestVisitor(): Visitor<JavaScriptTypeManifest> & {
+        registerDefinedTypes?: ((definedTypes: nodes.DefinedTypeNode[]) => void) | undefined;
+    };
+    protected getInstructionAccountType(account: ResolvedInstructionAccount): string;
+    protected getInstructionAccountImports(accounts: ResolvedInstructionAccount[]): JavaScriptImportMap;
+    protected getMergeConflictsForInstructionAccountsAndArgs(instruction: nodes.InstructionNode): string[];
+    protected render(template: string, context?: object, options?: ConfigureOptions): string;
+}

package/dist/types/renderers/js/GetJavaScriptTypeManifestVisitor.d.ts

@@ -0,0 +1,44 @@
+import * as nodes from '../../nodes';
+import { Visitor } from '../../visitors';
+import { JavaScriptImportMap } from './JavaScriptImportMap';
+export type JavaScriptTypeManifest = {
+    strictType: string;
+    looseType: string;
+    hasLooseType: boolean;
+    isEnum: boolean;
+    serializer: string;
+    imports: JavaScriptImportMap;
+};
+export declare class GetJavaScriptTypeManifestVisitor implements Visitor<JavaScriptTypeManifest> {
+    readonly serializerVariable: string;
+    private availableDefinedTypes;
+    private visitedDefinedTypes;
+    private definedTypeStack;
+    private definedName;
+    constructor(serializerVariable?: string);
+    registerDefinedTypes(definedTypes: nodes.DefinedTypeNode[]): void;
+    visitRoot(): JavaScriptTypeManifest;
+    visitProgram(): JavaScriptTypeManifest;
+    visitAccount(account: nodes.AccountNode): JavaScriptTypeManifest;
+    visitInstruction(instruction: nodes.InstructionNode): JavaScriptTypeManifest;
+    visitDefinedType(definedType: nodes.DefinedTypeNode): JavaScriptTypeManifest;
+    visitError(): JavaScriptTypeManifest;
+    visitTypeArray(typeArray: nodes.TypeArrayNode): JavaScriptTypeManifest;
+    visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): JavaScriptTypeManifest;
+    visitTypeEnum(typeEnum: nodes.TypeEnumNode): JavaScriptTypeManifest;
+    visitTypeEnumEmptyVariant(typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode): JavaScriptTypeManifest;
+    visitTypeEnumStructVariant(typeEnumStructVariant: nodes.TypeEnumStructVariantNode): JavaScriptTypeManifest;
+    visitTypeEnumTupleVariant(typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode): JavaScriptTypeManifest;
+    visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): JavaScriptTypeManifest;
+    visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): JavaScriptTypeManifest;
+    visitTypeMap(typeMap: nodes.TypeMapNode): JavaScriptTypeManifest;
+    visitTypeOption(typeOption: nodes.TypeOptionNode): JavaScriptTypeManifest;
+    visitTypeSet(typeSet: nodes.TypeSetNode): JavaScriptTypeManifest;
+    visitTypeStruct(typeStruct: nodes.TypeStructNode): JavaScriptTypeManifest;
+    visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): JavaScriptTypeManifest;
+    visitTypeTuple(typeTuple: nodes.TypeTupleNode): JavaScriptTypeManifest;
+    visitTypeVec(typeVec: nodes.TypeVecNode): JavaScriptTypeManifest;
+    protected s(name: string): string;
+    protected mergeManifests(manifests: JavaScriptTypeManifest[]): Pick<JavaScriptTypeManifest, 'imports' | 'hasLooseType' | 'isEnum'>;
+    protected createDocblock(docs: string[]): string;
+}

package/dist/types/renderers/js/GetJavaScriptValidatorBagVisitor.d.ts

@@ -0,0 +1,19 @@
+import * as nodes from '../../nodes';
+import { GetDefaultValidatorBagVisitor, NodeStack, ValidatorBag } from '../../visitors';
+export declare class GetJavaScriptValidatorBagVisitor extends GetDefaultValidatorBagVisitor {
+    protected exportMap: Map<string, {
+        node: nodes.Node;
+        stack: NodeStack;
+        exportType: string;
+    }>;
+    visitRoot(root: nodes.RootNode): ValidatorBag;
+    visitProgram(program: nodes.ProgramNode): ValidatorBag;
+    visitAccount(account: nodes.AccountNode): ValidatorBag;
+    visitInstruction(instruction: nodes.InstructionNode): ValidatorBag;
+    visitDefinedType(definedType: nodes.DefinedTypeNode): ValidatorBag;
+    visitError(error: nodes.ErrorNode): ValidatorBag;
+    visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): ValidatorBag;
+    protected checkExportConflicts(node: nodes.Node, exports: Record<string, string>): ValidatorBag;
+    protected isEponymousExport(node: nodes.Node, exportName: string): boolean;
+    protected getNodeTitle(node: nodes.Node): string;
+}

package/dist/types/renderers/js/JavaScriptImportMap.d.ts

@@ -0,0 +1,11 @@
+import { Dependency } from '../../visitors';
+export declare class JavaScriptImportMap {
+    protected readonly _imports: Map<Dependency, Set<string>>;
+    protected readonly _aliases: Map<Dependency, Record<string, string>>;
+    add(module: Dependency, imports: string | string[] | Set<string>): JavaScriptImportMap;
+    remove(module: Dependency, imports: string | string[] | Set<string>): JavaScriptImportMap;
+    mergeWith(...others: JavaScriptImportMap[]): JavaScriptImportMap;
+    addAlias(module: Dependency, name: string, alias: string): JavaScriptImportMap;
+    isEmpty(): boolean;
+    toString(dependencies: Record<Dependency, string>): string;
+}

package/dist/types/renderers/js/RenderJavaScriptValueNode.d.ts

@@ -0,0 +1,6 @@
+import * as nodes from '../../nodes';
+import { JavaScriptImportMap } from './JavaScriptImportMap';
+export declare function renderJavaScriptValueNode(value: nodes.ValueNode, types: Map<string, nodes.DefinedTypeNode>): {
+    imports: JavaScriptImportMap;
+    render: string;
+};

package/dist/types/renderers/js/RenderJavaScriptVisitor.d.ts

@@ -0,0 +1,14 @@
+import { LogLevel } from '../../logs';
+import * as nodes from '../../nodes';
+import { BaseThrowVisitor } from '../../visitors';
+import { GetJavaScriptRenderMapOptions } from './GetJavaScriptRenderMapVisitor';
+export type RenderJavaScriptOptions = GetJavaScriptRenderMapOptions & {
+    deleteFolderBeforeRendering?: boolean;
+    throwLevel?: LogLevel;
+};
+export declare class RenderJavaScriptVisitor extends BaseThrowVisitor<void> {
+    readonly path: string;
+    readonly options: RenderJavaScriptOptions;
+    constructor(path: string, options?: RenderJavaScriptOptions);
+    visitRoot(root: nodes.RootNode): void;
+}

package/dist/types/renderers/js/index.d.ts

@@ -0,0 +1,6 @@
+export * from './GetJavaScriptRenderMapVisitor';
+export * from './GetJavaScriptTypeManifestVisitor';
+export * from './GetJavaScriptValidatorBagVisitor';
+export * from './RenderJavaScriptValueNode';
+export * from './JavaScriptImportMap';
+export * from './RenderJavaScriptVisitor';

package/dist/types/renderers/utils.d.ts

@@ -0,0 +1,5 @@
+import { ConfigureOptions } from 'nunjucks';
+export declare const createDirectory: (path: string) => void;
+export declare const createFile: (path: string, content: string) => void;
+export declare const resolveTemplate: (directory: string, file: string, context?: object, options?: ConfigureOptions) => string;
+export declare const deleteFolder: (path: string) => void;

package/dist/types/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function readJson<T extends object>(value: string): T;
+export declare function capitalize(str: string): string;
+export declare function titleCase(str: string): string;
+export declare function pascalCase(str: string): string;
+export declare function camelCase(str: string): string;
+export declare function kebabCase(str: string): string;
+export declare function snakeCase(str: string): string;
+export declare function mainCase(str: string): string;

package/dist/types/visitors/BaseDelegateVisitor.d.ts

@@ -0,0 +1,28 @@
+import type * as nodes from '../nodes';
+import { Visitor } from './Visitor';
+export declare abstract class BaseDelegateVisitor<T, U> implements Visitor<U> {
+    readonly visitor: Visitor<T>;
+    constructor(visitor: Visitor<T>);
+    abstract map(value: T): U;
+    visitRoot(root: nodes.RootNode): U;
+    visitProgram(program: nodes.ProgramNode): U;
+    visitAccount(account: nodes.AccountNode): U;
+    visitInstruction(instruction: nodes.InstructionNode): U;
+    visitDefinedType(definedType: nodes.DefinedTypeNode): U;
+    visitError(error: nodes.ErrorNode): U;
+    visitTypeArray(typeArray: nodes.TypeArrayNode): U;
+    visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): U;
+    visitTypeEnum(typeEnum: nodes.TypeEnumNode): U;
+    visitTypeEnumEmptyVariant(typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode): U;
+    visitTypeEnumStructVariant(typeEnumStructVariant: nodes.TypeEnumStructVariantNode): U;
+    visitTypeEnumTupleVariant(typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode): U;
+    visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): U;
+    visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): U;
+    visitTypeMap(typeMap: nodes.TypeMapNode): U;
+    visitTypeOption(typeOption: nodes.TypeOptionNode): U;
+    visitTypeSet(typeSet: nodes.TypeSetNode): U;
+    visitTypeStruct(typeStruct: nodes.TypeStructNode): U;
+    visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): U;
+    visitTypeTuple(typeTuple: nodes.TypeTupleNode): U;
+    visitTypeVec(typeVec: nodes.TypeVecNode): U;
+}

package/dist/types/visitors/BaseNodeOrNullVisitor.d.ts

@@ -0,0 +1,25 @@
+import type { Visitor } from './Visitor';
+import * as nodes from '../nodes';
+export declare class BaseNodeOrNullVisitor implements Visitor<nodes.Node | null> {
+    visitRoot(root: nodes.RootNode): nodes.Node | null;
+    visitProgram(program: nodes.ProgramNode): nodes.Node | null;
+    visitAccount(account: nodes.AccountNode): nodes.Node | null;
+    visitInstruction(instruction: nodes.InstructionNode): nodes.Node | null;
+    visitDefinedType(definedType: nodes.DefinedTypeNode): nodes.Node | null;
+    visitError(error: nodes.ErrorNode): nodes.Node | null;
+    visitTypeArray(typeArray: nodes.TypeArrayNode): nodes.Node | null;
+    visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): nodes.Node | null;
+    visitTypeEnum(typeEnum: nodes.TypeEnumNode): nodes.Node | null;
+    visitTypeEnumEmptyVariant(typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode): nodes.Node | null;
+    visitTypeEnumStructVariant(typeEnumStructVariant: nodes.TypeEnumStructVariantNode): nodes.Node | null;
+    visitTypeEnumTupleVariant(typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode): nodes.Node | null;
+    visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): nodes.Node | null;
+    visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): nodes.Node | null;
+    visitTypeMap(typeMap: nodes.TypeMapNode): nodes.Node | null;
+    visitTypeOption(typeOption: nodes.TypeOptionNode): nodes.Node | null;
+    visitTypeSet(typeSet: nodes.TypeSetNode): nodes.Node | null;
+    visitTypeStruct(typeStruct: nodes.TypeStructNode): nodes.Node | null;
+    visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): nodes.Node | null;
+    visitTypeTuple(typeTuple: nodes.TypeTupleNode): nodes.Node | null;
+    visitTypeVec(typeVec: nodes.TypeVecNode): nodes.Node | null;
+}

package/dist/types/visitors/BaseNodeVisitor.d.ts

@@ -0,0 +1,25 @@
+import type { Visitor } from './Visitor';
+import * as nodes from '../nodes';
+export declare class BaseNodeVisitor implements Visitor<nodes.Node> {
+    visitRoot(root: nodes.RootNode): nodes.Node;
+    visitProgram(program: nodes.ProgramNode): nodes.Node;
+    visitAccount(account: nodes.AccountNode): nodes.Node;
+    visitInstruction(instruction: nodes.InstructionNode): nodes.Node;
+    visitDefinedType(definedType: nodes.DefinedTypeNode): nodes.Node;
+    visitError(error: nodes.ErrorNode): nodes.Node;
+    visitTypeArray(typeArray: nodes.TypeArrayNode): nodes.Node;
+    visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): nodes.Node;
+    visitTypeEnum(typeEnum: nodes.TypeEnumNode): nodes.Node;
+    visitTypeEnumEmptyVariant(typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode): nodes.Node;
+    visitTypeEnumStructVariant(typeEnumStructVariant: nodes.TypeEnumStructVariantNode): nodes.Node;
+    visitTypeEnumTupleVariant(typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode): nodes.Node;
+    visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): nodes.Node;
+    visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): nodes.Node;
+    visitTypeMap(typeMap: nodes.TypeMapNode): nodes.Node;
+    visitTypeOption(typeOption: nodes.TypeOptionNode): nodes.Node;
+    visitTypeSet(typeSet: nodes.TypeSetNode): nodes.Node;
+    visitTypeStruct(typeStruct: nodes.TypeStructNode): nodes.Node;
+    visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): nodes.Node;
+    visitTypeTuple(typeTuple: nodes.TypeTupleNode): nodes.Node;
+    visitTypeVec(typeVec: nodes.TypeVecNode): nodes.Node;
+}

package/dist/types/visitors/BaseThrowVisitor.d.ts

@@ -0,0 +1,25 @@
+import * as nodes from '../nodes';
+import type { Visitor } from './Visitor';
+export declare class BaseThrowVisitor<T> implements Visitor<T> {
+    visitRoot(root: nodes.RootNode): T;
+    visitProgram(program: nodes.ProgramNode): T;
+    visitAccount(account: nodes.AccountNode): T;
+    visitInstruction(instruction: nodes.InstructionNode): T;
+    visitDefinedType(definedType: nodes.DefinedTypeNode): T;
+    visitError(error: nodes.ErrorNode): T;
+    visitTypeArray(typeArray: nodes.TypeArrayNode): T;
+    visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): T;
+    visitTypeEnum(typeEnum: nodes.TypeEnumNode): T;
+    visitTypeEnumEmptyVariant(typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode): T;
+    visitTypeEnumStructVariant(typeEnumStructVariant: nodes.TypeEnumStructVariantNode): T;
+    visitTypeEnumTupleVariant(typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode): T;
+    visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): T;
+    visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): T;
+    visitTypeMap(typeMap: nodes.TypeMapNode): T;
+    visitTypeOption(typeOption: nodes.TypeOptionNode): T;
+    visitTypeSet(typeSet: nodes.TypeSetNode): T;
+    visitTypeStruct(typeStruct: nodes.TypeStructNode): T;
+    visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): T;
+    visitTypeTuple(typeTuple: nodes.TypeTupleNode): T;
+    visitTypeVec(typeVec: nodes.TypeVecNode): T;
+}

package/dist/types/visitors/BaseVoidVisitor.d.ts

@@ -0,0 +1,25 @@
+import * as nodes from '../nodes';
+import type { Visitor } from './Visitor';
+export declare abstract class BaseVoidVisitor implements Visitor<void> {
+    visitRoot(root: nodes.RootNode): void;
+    visitProgram(program: nodes.ProgramNode): void;
+    visitAccount(account: nodes.AccountNode): void;
+    visitInstruction(instruction: nodes.InstructionNode): void;
+    visitDefinedType(definedType: nodes.DefinedTypeNode): void;
+    visitError(error: nodes.ErrorNode): void;
+    visitTypeArray(typeArray: nodes.TypeArrayNode): void;
+    visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): void;
+    visitTypeEnum(typeEnum: nodes.TypeEnumNode): void;
+    visitTypeEnumEmptyVariant(typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode): void;
+    visitTypeEnumStructVariant(typeEnumStructVariant: nodes.TypeEnumStructVariantNode): void;
+    visitTypeEnumTupleVariant(typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode): void;
+    visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): void;
+    visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): void;
+    visitTypeMap(typeMap: nodes.TypeMapNode): void;
+    visitTypeOption(typeOption: nodes.TypeOptionNode): void;
+    visitTypeSet(typeSet: nodes.TypeSetNode): void;
+    visitTypeStruct(typeStruct: nodes.TypeStructNode): void;
+    visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): void;
+    visitTypeTuple(typeTuple: nodes.TypeTupleNode): void;
+    visitTypeVec(typeVec: nodes.TypeVecNode): void;
+}

package/dist/types/visitors/DefaultVisitor.d.ts

@@ -0,0 +1,5 @@
+import * as nodes from '../nodes';
+import { BaseThrowVisitor } from './BaseThrowVisitor';
+export declare class DefaultVisitor extends BaseThrowVisitor<nodes.RootNode> {
+    visitRoot(currentRoot: nodes.RootNode): nodes.RootNode;
+}

package/dist/types/visitors/Dependency.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tells Kinobi where a dependency is located.
+ * This could be a recognized dependency, or any other string
+ * as long as renderers know how to map them into real libraries.
+ */
+export type Dependency = RelativeDependecy | 'core' | 'mplEssentials' | 'mplDigitalAsset' | string;
+/**
+ * Tells Kinobi where a local dependency is located.
+ * - `generated` means the dependency is located in the `generated` folder.
+ * - `root` means the dependency is located in the source folder, outside of the `generated` folder.
+ * - `rootHooked` means the dependency is located outside of the `generated` folder, in a
+ *    special folder that is used internally by the auto-generated code.
+ *
+ * These can be interpreted by renderers as they see fit as different languages
+ * have different ways of importing local files.
+ */
+export type RelativeDependecy = 'generated' | 'root' | 'rootHooked';

package/dist/types/visitors/NodeSelector.d.ts

@@ -0,0 +1,11 @@
+import * as nodes from '../nodes';
+import type { NodeStack } from './NodeStack';
+export type NodeSelectorType = 'program' | 'instruction' | 'account' | 'definedType' | 'error' | 'typeDefinedLink' | 'typeStruct' | 'typeLeaf';
+export type NodeSelector = {
+    type: NodeSelectorType | '*';
+    name?: string;
+    stack?: string | string[];
+    program?: string;
+} | NodeSelectorFunction;
+export type NodeSelectorFunction = (node: nodes.Node, stack: NodeStack, program: nodes.ProgramNode | null) => boolean;
+export declare const toNodeSelectorFunction: (selector: NodeSelector) => NodeSelectorFunction;

package/dist/types/visitors/NodeStack.d.ts

@@ -0,0 +1,14 @@
+import * as nodes from '../nodes';
+export declare class NodeStack {
+    private readonly stack;
+    constructor(stack?: nodes.Node[]);
+    push(node: nodes.Node): void;
+    pop(): nodes.Node | undefined;
+    peek(): nodes.Node | undefined;
+    all(): nodes.Node[];
+    isEmpty(): boolean;
+    clone(): NodeStack;
+    toString(): string;
+    toStringArray(): string[];
+    matchesWithNames(names: string[]): boolean;
+}

package/dist/types/visitors/ValidatorBag.d.ts

@@ -0,0 +1,22 @@
+import { LogLevel } from '../logs';
+import * as nodes from '../nodes';
+import { NodeStack } from './NodeStack';
+export type ValidatorItem = {
+    message: string;
+    level: LogLevel;
+    node: nodes.Node;
+    stack: NodeStack;
+};
+export declare class ValidatorBag {
+    readonly items: ValidatorItem[];
+    constructor(items?: ValidatorItem[]);
+    add(item: ValidatorItem): ValidatorBag;
+    mergeWith(others: ValidatorBag[]): ValidatorBag;
+    error(message: string, node: nodes.Node, stack: NodeStack): ValidatorBag;
+    warn(message: string, node: nodes.Node, stack: NodeStack): ValidatorBag;
+    info(message: string, node: nodes.Node, stack: NodeStack): ValidatorBag;
+    trace(message: string, node: nodes.Node, stack: NodeStack): ValidatorBag;
+    debug(message: string, node: nodes.Node, stack: NodeStack): ValidatorBag;
+    orderByLevel(): ValidatorBag;
+    log(): void;
+}

package/dist/types/visitors/Visitable.d.ts

@@ -0,0 +1,4 @@
+import type { Visitor } from './Visitor';
+export interface Visitable {
+    accept<T>(visitor: Visitor<T>): T;
+}

package/dist/types/visitors/Visitor.d.ts

@@ -0,0 +1,24 @@
+import type * as nodes from '../nodes';
+export interface Visitor<T = void> {
+    visitRoot: (root: nodes.RootNode) => T;
+    visitProgram: (program: nodes.ProgramNode) => T;
+    visitAccount: (account: nodes.AccountNode) => T;
+    visitInstruction: (instruction: nodes.InstructionNode) => T;
+    visitDefinedType: (definedType: nodes.DefinedTypeNode) => T;
+    visitError: (error: nodes.ErrorNode) => T;
+    visitTypeArray: (typeArray: nodes.TypeArrayNode) => T;
+    visitTypeDefinedLink: (typeDefinedLink: nodes.TypeDefinedLinkNode) => T;
+    visitTypeEnum: (typeEnum: nodes.TypeEnumNode) => T;
+    visitTypeEnumEmptyVariant: (typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode) => T;
+    visitTypeEnumStructVariant: (typeEnumStructVariant: nodes.TypeEnumStructVariantNode) => T;
+    visitTypeEnumTupleVariant: (typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode) => T;
+    visitTypeLeaf: (typeLeaf: nodes.TypeLeafNode) => T;
+    visitTypeLeafWrapper: (typeLeafWrapper: nodes.TypeLeafWrapperNode) => T;
+    visitTypeMap: (typeMap: nodes.TypeMapNode) => T;
+    visitTypeOption: (typeOption: nodes.TypeOptionNode) => T;
+    visitTypeSet: (typeSet: nodes.TypeSetNode) => T;
+    visitTypeStruct: (typeStruct: nodes.TypeStructNode) => T;
+    visitTypeStructField: (typeStructField: nodes.TypeStructFieldNode) => T;
+    visitTypeTuple: (typeTuple: nodes.TypeTupleNode) => T;
+    visitTypeVec: (typeVec: nodes.TypeVecNode) => T;
+}

package/dist/types/visitors/aggregators/GetByteSizeVisitor.d.ts

@@ -0,0 +1,27 @@
+import * as nodes from '../../nodes';
+import { BaseThrowVisitor } from '../BaseThrowVisitor';
+export declare class GetByteSizeVisitor extends BaseThrowVisitor<number | null> {
+    private availableDefinedTypes;
+    private visitedDefinedTypes;
+    private definedTypeStack;
+    registerDefinedTypes(definedTypes: nodes.DefinedTypeNode[]): void;
+    visitAccount(account: nodes.AccountNode): number | null;
+    visitInstruction(instruction: nodes.InstructionNode): number | null;
+    visitDefinedType(definedType: nodes.DefinedTypeNode): number | null;
+    visitTypeArray(typeArray: nodes.TypeArrayNode): number | null;
+    visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): number | null;
+    visitTypeEnum(typeEnum: nodes.TypeEnumNode): number | null;
+    visitTypeEnumEmptyVariant(): number | null;
+    visitTypeEnumStructVariant(typeEnumStructVariant: nodes.TypeEnumStructVariantNode): number | null;
+    visitTypeEnumTupleVariant(typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode): number | null;
+    visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): number | null;
+    visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): number | null;
+    visitTypeMap(): number | null;
+    visitTypeOption(typeOption: nodes.TypeOptionNode): number | null;
+    visitTypeSet(): number | null;
+    visitTypeStruct(typeStruct: nodes.TypeStructNode): number | null;
+    visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): number | null;
+    visitTypeTuple(typeTuple: nodes.TypeTupleNode): number | null;
+    visitTypeVec(): number | null;
+    protected sumSizes(sizes: (number | null)[]): number | null;
+}