@algorandfoundation/puya-ts 1.0.0-alpha.10

package/awst_build/ptypes/index.d.ts

@@ -0,0 +1,464 @@
+import { wtypes } from '../../awst';
+import { TransactionKind } from '../../awst/models';
+import type { WType } from '../../awst/wtypes';
+import { WEnumeration, WTuple } from '../../awst/wtypes';
+import { PType } from './base';
+export * from './base';
+export * from './intrinsic-enum-type';
+export * from './op-ptypes';
+/**
+ * Transient types can appear in expressions but should not be used as variable or return types
+ */
+export declare abstract class TransientType extends PType {
+    readonly name: string;
+    readonly module: string;
+    readonly singleton: boolean;
+    readonly typeMessage: string;
+    readonly expressionMessage: string;
+    constructor({ name, module, singleton, typeMessage, expressionMessage, }: {
+        name: string;
+        module: string;
+        singleton: boolean;
+        typeMessage: string;
+        expressionMessage: string;
+    });
+    get wtype(): WType | undefined;
+    get wtypeOrThrow(): WType;
+}
+export declare class UnsupportedType extends PType {
+    #private;
+    readonly wtype: undefined;
+    readonly name: string;
+    readonly module: string;
+    readonly singleton = false;
+    constructor({ name, module, fullName }: {
+        name: string;
+        module: string;
+        fullName?: string;
+    });
+    get fullName(): string;
+    get wtypeOrThrow(): WType;
+}
+export declare class ContractClassPType extends PType {
+    readonly wtype: undefined;
+    readonly name: string;
+    readonly module: string;
+    readonly properties: Record<string, PType>;
+    readonly methods: Record<string, FunctionPType>;
+    readonly singleton = true;
+    readonly baseTypes: ContractClassPType[];
+    constructor(props: {
+        module: string;
+        name: string;
+        properties: Record<string, AppStorageType>;
+        methods: Record<string, FunctionPType>;
+        baseTypes: ContractClassPType[];
+    });
+    get isARC4(): boolean;
+}
+export declare class BaseContractClassType extends ContractClassPType {
+    readonly _isArc4: boolean;
+    get isARC4(): boolean;
+    constructor({ isArc4, ...rest }: {
+        isArc4: boolean;
+        module: string;
+        name: string;
+        properties: Record<string, AppStorageType>;
+        methods: Record<string, FunctionPType>;
+        baseTypes: ContractClassPType[];
+    });
+}
+export declare class UnionPType extends TransientType {
+    get fullName(): string;
+    readonly singleton = false;
+    readonly types: PType[];
+    private constructor();
+    static fromTypes(types: PType[]): PType;
+}
+export declare abstract class StorageProxyPType extends PType {
+    readonly wtype: WType;
+    readonly contentType: PType;
+    readonly singleton = false;
+    protected constructor(props: {
+        content: PType;
+        keyWType: WType;
+    });
+    abstract getGenericArgs(): PType[];
+}
+export declare class GlobalStateType extends StorageProxyPType {
+    static readonly baseName = "GlobalState";
+    static readonly baseFullName: string;
+    readonly module: string;
+    get name(): string;
+    get fullName(): string;
+    constructor(props: {
+        content: PType;
+    });
+    static parameterise(typeArgs: PType[]): GlobalStateType;
+    getGenericArgs(): PType[];
+}
+export declare class LocalStateType extends StorageProxyPType {
+    static readonly baseName = "LocalState";
+    static readonly baseFullName: string;
+    readonly module: string;
+    get name(): string;
+    get fullName(): string;
+    constructor(props: {
+        content: PType;
+    });
+    static parameterise(typeArgs: PType[]): LocalStateType;
+    getGenericArgs(): PType[];
+}
+export declare class BoxPType extends StorageProxyPType {
+    static readonly baseName = "Box";
+    static readonly baseFullName: string;
+    readonly module: string;
+    get name(): string;
+    get fullName(): string;
+    constructor(props: {
+        content: PType;
+    });
+    static parameterise(typeArgs: PType[]): BoxPType;
+    getGenericArgs(): PType[];
+}
+export declare class BoxMapPType extends StorageProxyPType {
+    static readonly baseName = "BoxMap";
+    static readonly baseFullName: string;
+    readonly module: string;
+    get name(): string;
+    get fullName(): string;
+    readonly keyType: PType;
+    constructor(props: {
+        content: PType;
+        keyType: PType;
+    });
+    static parameterise(typeArgs: PType[]): BoxMapPType;
+    getGenericArgs(): PType[];
+}
+export declare class BoxRefPType extends StorageProxyPType {
+    readonly module: "@algorandfoundation/algorand-typescript/box.d.ts";
+    get name(): string;
+    constructor();
+    getGenericArgs(): PType[];
+}
+export type AppStorageType = GlobalStateType | LocalStateType;
+export declare function isAppStorageType(ptype: PType): ptype is AppStorageType;
+/**
+ * An open generic type parameter
+ */
+export declare class TypeParameterType extends PType {
+    readonly name: string;
+    readonly module: string;
+    readonly singleton = false;
+    readonly wtype: undefined;
+    constructor({ name, module }: {
+        name: string;
+        module: string;
+    });
+}
+/**
+ * A type from the typescript libs which might pop up in type reflection
+ * but is not relevant to the output of the compiler
+ */
+export declare class InternalType extends PType {
+    readonly name: string;
+    readonly module: string;
+    readonly singleton = false;
+    readonly wtype: undefined;
+    constructor({ name, module }: {
+        name: string;
+        module: string;
+    });
+}
+export declare const ClassMethodDecoratorContext: InternalType;
+export declare class AnyPType extends PType {
+    get wtype(): never;
+    readonly name = "any";
+    readonly module = "lib.d.ts";
+    readonly singleton = false;
+}
+export declare class InstanceType extends PType {
+    readonly wtype: wtypes.WType;
+    readonly name: string;
+    readonly module: string;
+    readonly singleton = false;
+    constructor({ name, module, wtype }: {
+        name: string;
+        module: string;
+        wtype: wtypes.WType;
+    });
+}
+export declare class LibFunctionType extends PType {
+    readonly wtype: undefined;
+    readonly name: string;
+    readonly module: string;
+    readonly singleton = true;
+    constructor({ name, module }: {
+        name: string;
+        module: string;
+    });
+}
+export declare class IntrinsicFunctionGroupType extends PType {
+    readonly wtype: undefined;
+    readonly name: string;
+    readonly module: string;
+    readonly singleton = true;
+    constructor({ name }: {
+        name: string;
+    });
+}
+export declare class IntrinsicFunctionType extends PType {
+    readonly wtype: undefined;
+    readonly name: string;
+    readonly module: string;
+    readonly singleton = true;
+    constructor({ name }: {
+        name: string;
+    });
+}
+export declare class NamespacePType extends PType {
+    readonly wtype: undefined;
+    readonly name: string;
+    readonly factory: undefined;
+    readonly module: string;
+    readonly singleton = true;
+    constructor({ name, module }: {
+        name: string;
+        module: string;
+    });
+    get fullName(): string;
+    toString(): string;
+}
+export declare class FunctionPType extends PType {
+    readonly wtype: undefined;
+    readonly name: string;
+    readonly module: string;
+    readonly returnType: PType;
+    readonly parameters: Array<readonly [string, PType]>;
+    readonly singleton = true;
+    constructor(props: {
+        name: string;
+        module: string;
+        returnType: PType;
+        parameters: Array<readonly [string, PType]>;
+    });
+}
+export declare class ArrayLiteralPType extends TransientType {
+    get fullName(): string;
+    readonly items: PType[];
+    readonly immutable = true;
+    constructor(props: {
+        items: PType[];
+    });
+    getArrayType(): ArrayPType;
+    getTupleType(): TuplePType;
+}
+export declare class TuplePType extends PType {
+    readonly module: string;
+    get name(): string;
+    get fullName(): string;
+    readonly items: PType[];
+    readonly singleton = false;
+    readonly immutable: boolean;
+    constructor(props: {
+        items: PType[];
+        immutable?: boolean;
+    });
+    get wtype(): WTuple;
+}
+export declare class ArrayPType extends TransientType {
+    readonly itemType: PType;
+    readonly immutable: boolean;
+    get fullName(): string;
+    constructor(props: {
+        itemType: PType;
+        immutable: boolean;
+    });
+    get wtype(): wtypes.WArray;
+}
+export declare class ObjectPType extends PType {
+    #private;
+    readonly module: string;
+    readonly properties: Record<string, PType>;
+    readonly singleton = false;
+    constructor(props: {
+        module?: string;
+        name?: string;
+        properties: Record<string, PType>;
+    });
+    static anonymous(props: Record<string, PType> | Array<[string, PType]>): ObjectPType;
+    get wtype(): WTuple;
+    orderedProperties(): [string, PType][];
+    getPropertyType(name: string): PType;
+    hasProperty(name: string): boolean;
+    hasPropertyOfType(name: string, type: PType): boolean;
+    get name(): string;
+    get fullName(): string;
+}
+export declare const voidPType: InstanceType;
+export declare const neverPType: InstanceType;
+export declare const unknownPType: UnsupportedType;
+export declare const nullPType: UnsupportedType;
+export declare const undefinedPType: UnsupportedType;
+export declare const anyPType: AnyPType;
+export declare const boolPType: InstanceType;
+export declare const BooleanFunction: LibFunctionType;
+export declare class NativeNumericType extends TransientType {
+}
+export declare const bigIntPType: NativeNumericType;
+export declare const stringPType: InstanceType;
+export declare const StringFunction: LibFunctionType;
+export declare const uint64PType: InstanceType;
+export declare const biguintPType: InstanceType;
+export declare class NumericLiteralPType extends NativeNumericType {
+    readonly literalValue: bigint;
+    constructor({ literalValue }: {
+        literalValue: bigint;
+    });
+}
+export declare class BigIntLiteralPType extends NativeNumericType {
+    readonly literalValue: bigint;
+    constructor({ literalValue }: {
+        literalValue: bigint;
+    });
+}
+export declare const numberPType: NativeNumericType;
+export declare const Uint64Function: LibFunctionType;
+export declare const BigUintFunction: LibFunctionType;
+export declare const bytesPType: InstanceType;
+export declare const BytesFunction: LibFunctionType;
+export declare const logFunction: LibFunctionType;
+export declare const assertFunction: LibFunctionType;
+export declare const errFunction: LibFunctionType;
+export declare const assetPType: InstanceType;
+export declare const AssetFunction: LibFunctionType;
+export declare const accountPType: InstanceType;
+export declare const AccountFunction: LibFunctionType;
+export declare const applicationPType: InstanceType;
+export declare const ApplicationFunctionType: LibFunctionType;
+export declare const GlobalStateFunction: LibFunctionType;
+export declare const LocalStateFunction: LibFunctionType;
+export declare const BoxFunction: LibFunctionType;
+export declare const BoxMapFunction: LibFunctionType;
+export declare const BoxRefFunction: LibFunctionType;
+export declare const boxRefType: BoxRefPType;
+export declare const ClearStateProgram: FunctionPType;
+export declare const ApprovalProgram: FunctionPType;
+export declare const baseContractType: BaseContractClassType;
+export declare const arc4BaseContractType: BaseContractClassType;
+export declare const arc4BareMethodDecorator: LibFunctionType;
+export declare const arc4AbiMethodDecorator: LibFunctionType;
+export declare class GroupTransactionPType extends PType {
+    get wtype(): wtypes.WGroupTransaction;
+    readonly name: string;
+    readonly kind: TransactionKind | undefined;
+    readonly module: "@algorandfoundation/algorand-typescript/gtxn.d.ts";
+    readonly singleton = false;
+    constructor({ kind, name }: {
+        kind?: TransactionKind;
+        name: string;
+    });
+}
+export declare class TransactionFunctionType extends LibFunctionType {
+    readonly kind: TransactionKind | undefined;
+    constructor({ name, module, kind }: {
+        name: string;
+        module: string;
+        kind: TransactionKind | undefined;
+    });
+}
+export declare const paymentGtxnType: GroupTransactionPType;
+export declare const PaymentTxnFunction: TransactionFunctionType;
+export declare const keyRegistrationGtxnType: GroupTransactionPType;
+export declare const KeyRegistrationTxnFunction: TransactionFunctionType;
+export declare const assetConfigGtxnType: GroupTransactionPType;
+export declare const AssetConfigTxnFunction: TransactionFunctionType;
+export declare const assetTransferGtxnType: GroupTransactionPType;
+export declare const AssetTransferTxnFunction: TransactionFunctionType;
+export declare const assetFreezeGtxnType: GroupTransactionPType;
+export declare const AssetFreezeTxnFunction: TransactionFunctionType;
+export declare const applicationCallGtxnType: GroupTransactionPType;
+export declare const ApplicationTxnFunction: TransactionFunctionType;
+export declare const anyGtxnType: GroupTransactionPType;
+export declare const TransactionFunction: TransactionFunctionType;
+export declare const assertMatchFunction: LibFunctionType;
+export declare class Uint64EnumMemberType extends PType {
+    readonly wtype: wtypes.WType;
+    readonly name: string;
+    readonly module: string;
+    readonly singleton = false;
+    readonly enumType: Uint64EnumType;
+    constructor(enumType: Uint64EnumType);
+}
+export declare class Uint64EnumType extends PType {
+    get memberType(): Uint64EnumMemberType;
+    readonly wtype: wtypes.WType;
+    readonly name: string;
+    readonly module: string;
+    readonly singleton = true;
+    readonly members: Record<string, bigint>;
+    constructor(props: {
+        name: string;
+        module: string;
+        members: Record<string, bigint>;
+    });
+}
+export declare const transactionTypeType: Uint64EnumType;
+export declare const onCompleteActionType: Uint64EnumType;
+export declare const ensureBudgetFunction: LibFunctionType;
+export declare const opUpFeeSourceType: Uint64EnumType;
+export declare const urangeFunction: LibFunctionType;
+export declare class IterableIteratorType extends TransientType {
+    readonly itemType: PType;
+    constructor({ itemType }: {
+        itemType: PType;
+    });
+    static readonly baseName = "IterableIterator";
+    static readonly moduleName = "typescript/lib/lib.es2015.iterable.d.ts";
+    static readonly baseFullName: string;
+    get fullName(): string;
+    static parameterise(typeArgs: PType[]): IterableIteratorType;
+    get wtype(): WEnumeration;
+    getGenericArgs(): PType[];
+}
+export declare const paymentItxnFn: TransactionFunctionType;
+export declare const keyRegistrationItxnFn: TransactionFunctionType;
+export declare const assetConfigItxnFn: TransactionFunctionType;
+export declare const assetTransferItxnFn: TransactionFunctionType;
+export declare const assetFreezeItxnFn: TransactionFunctionType;
+export declare const applicationCallItxnFn: TransactionFunctionType;
+export declare class InnerTransactionPType extends PType {
+    get wtype(): wtypes.WInnerTransaction;
+    readonly name: string;
+    readonly kind: TransactionKind | undefined;
+    readonly module: "@algorandfoundation/algorand-typescript/itxn.d.ts";
+    readonly singleton = false;
+    constructor({ kind, name }: {
+        kind?: TransactionKind;
+        name: string;
+    });
+}
+export declare class ItxnParamsPType extends PType {
+    get wtype(): wtypes.WInnerTransactionFields;
+    readonly name: string;
+    readonly kind: TransactionKind | undefined;
+    readonly module: "@algorandfoundation/algorand-typescript/itxn.d.ts";
+    readonly singleton = false;
+    constructor({ kind, name }: {
+        kind?: TransactionKind;
+        name: string;
+    });
+}
+export declare const paymentItxnParamsType: ItxnParamsPType;
+export declare const paymentItxnType: InnerTransactionPType;
+export declare const keyRegistrationItxnParamsType: ItxnParamsPType;
+export declare const keyRegistrationItxnType: InnerTransactionPType;
+export declare const assetConfigItxnParamsType: ItxnParamsPType;
+export declare const assetConfigItxnType: InnerTransactionPType;
+export declare const assetTransferItxnParamsType: ItxnParamsPType;
+export declare const assetTransferItxnType: InnerTransactionPType;
+export declare const assetFreezeItxnParamsType: ItxnParamsPType;
+export declare const assetFreezeItxnType: InnerTransactionPType;
+export declare const applicationCallItxnParamsType: ItxnParamsPType;
+export declare const applicationItxnType: InnerTransactionPType;
+export declare const submitGroupItxnFunction: LibFunctionType;

package/awst_build/ptypes/intrinsic-enum-type.d.ts

@@ -0,0 +1,14 @@
+import { PType } from './base';
+export declare class IntrinsicEnumType extends PType {
+    readonly wtype: undefined;
+    readonly name: string;
+    readonly factory: undefined;
+    readonly module: string;
+    readonly members: Array<[string, string]>;
+    readonly singleton = true;
+    constructor({ name, module, members }: {
+        name: string;
+        module: string;
+        members: Array<[string, string]>;
+    });
+}

package/awst_build/ptypes/op-ptypes.d.ts

@@ -0,0 +1,6 @@
+import { IntrinsicEnumType } from './intrinsic-enum-type';
+export declare const base64PType: IntrinsicEnumType;
+export declare const ecPType: IntrinsicEnumType;
+export declare const ecdsaPType: IntrinsicEnumType;
+export declare const vrfVerifyPType: IntrinsicEnumType;
+export declare const ALL_OP_ENUMS: IntrinsicEnumType[];

package/awst_build/ptypes/register.d.ts

@@ -0,0 +1,2 @@
+import type { TypeRegistry } from '../type-registry';
+export declare function registerPTypes(typeRegistry: TypeRegistry): void;

package/awst_build/ptypes/transient-type-errors.d.ts

@@ -0,0 +1,14 @@
+export declare const transientTypeErrors: {
+    arrays: (typeName: string) => {
+        usedAsType: string;
+        usedInExpression: string;
+    };
+    nativeNumeric: (typeName: string) => {
+        usedAsType: string;
+        usedInExpression: string;
+    };
+    unionTypes: (typeName: string) => {
+        usedAsType: string;
+        usedInExpression: string;
+    };
+};

package/awst_build/source-file-visitor.d.ts

@@ -0,0 +1,21 @@
+import ts from 'typescript';
+import type * as awst from '../awst/nodes';
+import type { ModuleStatements } from '../visitor/syntax-names';
+import type { Visitor } from '../visitor/visitor';
+import { BaseVisitor } from './base-visitor';
+import type { AwstBuildContext } from './context/awst-build-context';
+type NodeOrDeferred = awst.AWST[] | awst.AWST | (() => awst.AWST[] | awst.AWST);
+export declare class SourceFileVisitor extends BaseVisitor implements Visitor<ModuleStatements, NodeOrDeferred> {
+    private _moduleStatements;
+    private accept;
+    constructor(context: AwstBuildContext, sourceFile: ts.SourceFile);
+    visitInterfaceDeclaration(node: ts.InterfaceDeclaration): NodeOrDeferred;
+    visitTypeAliasDeclaration(_node: ts.TypeAliasDeclaration): NodeOrDeferred;
+    visitFunctionDeclaration(node: ts.FunctionDeclaration): NodeOrDeferred;
+    buildModule(): awst.AWST[];
+    private gatherStatements;
+    visitVariableStatement(node: ts.VariableStatement): NodeOrDeferred;
+    visitImportDeclaration(_node: ts.ImportDeclaration): NodeOrDeferred;
+    visitClassDeclaration(node: ts.ClassDeclaration): NodeOrDeferred;
+}
+export {};

package/awst_build/subroutine-visitor.d.ts

@@ -0,0 +1,10 @@
+import type ts from 'typescript';
+import * as awst from '../awst/nodes';
+import type { AwstBuildContext } from './context/awst-build-context';
+import { FunctionVisitor } from './function-visitor';
+export declare class SubroutineVisitor extends FunctionVisitor {
+    private readonly _result;
+    constructor(ctx: AwstBuildContext, node: ts.FunctionDeclaration);
+    get result(): awst.Subroutine;
+    static buildSubroutine(parentCtx: AwstBuildContext, node: ts.FunctionDeclaration): awst.Subroutine;
+}

package/awst_build/symbol-name.d.ts

@@ -0,0 +1,10 @@
+export declare class SymbolName {
+    readonly module: string;
+    readonly name: string;
+    constructor(props: {
+        module: string;
+        name: string;
+    });
+    get fullName(): string;
+    toString(): string;
+}

package/awst_build/text-visitor.d.ts

@@ -0,0 +1,20 @@
+import type * as ts from 'typescript';
+import type { Visitor } from '../visitor/visitor';
+import type { AwstBuildContext } from './context/awst-build-context';
+type ObjectNames = ts.PropertyName | ts.PseudoLiteralToken;
+export declare class TextVisitor implements Visitor<ObjectNames, string> {
+    context: AwstBuildContext;
+    constructor(context: AwstBuildContext);
+    visitBigIntLiteral(node: ts.BigIntLiteral): string;
+    visitTemplateHead(node: ts.TemplateHead): string;
+    visitTemplateMiddle(node: ts.TemplateMiddle): string;
+    visitTemplateTail(node: ts.TemplateTail): string;
+    accept: <TNode extends ts.Node>(node: TNode) => import("../visitor/visitor").MethodReturnType<import("../visitor/visitor").VisitorMethod<import("../visitor/visitor").KindForNode<import("../visitor/syntax-names").MapBaseType<TNode>>>, TextVisitor>;
+    visitIdentifier(node: ts.Identifier): string;
+    visitNoSubstitutionTemplateLiteral(node: ts.NoSubstitutionTemplateLiteral): string;
+    visitNumericLiteral(node: ts.NumericLiteral): string;
+    visitComputedPropertyName(node: ts.ComputedPropertyName): string;
+    visitPrivateIdentifier(node: ts.PrivateIdentifier): string;
+    visitStringLiteral(node: ts.StringLiteral): string;
+}
+export {};

package/awst_build/type-registry.d.ts

@@ -0,0 +1,61 @@
+import type { awst } from '../awst';
+import type { SourceLocation } from '../awst/source-location';
+import type { DeliberateAny } from '../typescript-helpers';
+import type { InstanceBuilder, InstanceExpressionBuilder, NodeBuilder } from './eb';
+import { PType } from './ptypes';
+import type { SymbolName } from './symbol-name';
+type ValueExpressionBuilderCtor<TPType extends PType> = {
+    new (expr: awst.Expression, ptype: PType): InstanceExpressionBuilder<TPType>;
+};
+type SingletonExpressionBuilderCtor = {
+    new (sourceLocation: SourceLocation, ptype: PType): NodeBuilder;
+};
+type PTypeClass = {
+    new (...args: DeliberateAny): PType;
+};
+type GenericPTypeClass = {
+    new (...args: DeliberateAny): PType;
+    get baseFullName(): string;
+    parameterise(typeArgs: PType[]): PType;
+};
+export declare class TypeRegistry {
+    get hasRegistrations(): boolean;
+    private readonly singletonEbs;
+    private readonly instanceEbs;
+    private readonly types;
+    private readonly genericTypes;
+    register({ ptype, singletonEb, instanceEb, }: {
+        ptype: PType | PTypeClass;
+        singletonEb: SingletonExpressionBuilderCtor;
+        instanceEb?: undefined;
+    } | {
+        ptype: PType | PTypeClass;
+        singletonEb?: undefined;
+        instanceEb: ValueExpressionBuilderCtor<PType>;
+    }): void;
+    registerGeneric({ ptype, instanceEb }: {
+        ptype: GenericPTypeClass;
+        instanceEb: ValueExpressionBuilderCtor<PType>;
+    }): void;
+    isGeneric(ptype: PType): boolean;
+    /**
+     * Try to resolve a symbol name to a singleton ptype
+     * @param symbolName The name of the symbol
+     */
+    tryResolveSingletonName(symbolName: SymbolName): PType | undefined;
+    /**
+     * Try to resolve a symbol name to an instance ptype
+     * @param symbolName The name of the symbol
+     */
+    tryResolveInstancePType(symbolName: SymbolName): PType | undefined;
+    resolveInstancePType(symbolName: SymbolName, sourceLocation: SourceLocation): PType;
+    tryGetSingletonEb(ptype: PType, sourceLocation: SourceLocation): NodeBuilder | undefined;
+    getSingletonEb(ptype: PType, sourceLocation: SourceLocation): NodeBuilder;
+    getInstanceEb(expression: awst.Expression, ptype: PType): InstanceBuilder;
+    tryGetInstanceEb(expression: awst.Expression, ptype: PType): InstanceBuilder | undefined;
+    resolveGenericPType(symbolName: SymbolName, typeArgs: PType[], sourceLocation: SourceLocation): PType;
+    tryResolveGenericPType(symbolName: SymbolName, typeArgs: PType[]): PType | undefined;
+}
+export declare const typeRegistry: TypeRegistry;
+export declare function instanceEb(expr: awst.Expression, ptype: PType): InstanceBuilder<PType>;
+export {};

package/awst_build/type-resolver.d.ts

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+import type { SourceLocation } from '../awst/source-location';
+import type { PType } from './ptypes';
+export declare class TypeResolver {
+    private readonly checker;
+    private readonly programDirectory;
+    constructor(checker: ts.TypeChecker, programDirectory: string);
+    private getUnaliasedSymbolForNode;
+    resolveTypeParameters(node: ts.CallExpression, sourceLocation: SourceLocation): PType[];
+    resolve(node: ts.Node, sourceLocation: SourceLocation): PType;
+    resolveTypeNode(node: ts.TypeNode, sourceLocation: SourceLocation): PType;
+    resolveType(tsType: ts.Type, sourceLocation: SourceLocation): PType;
+    private reflectObjectType;
+    private reflectFunctionType;
+    private reflectContractType;
+    private getTypeName;
+    private getSymbolFullName;
+}

package/bin/run-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../cli';

package/bin/run-cli.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import '../cli.mjs';
+import 'commander';
+import 'zod';
+import 'glob';
+import 'node:fs';
+import 'upath';
+import '../index-GbFBpbmB.js';
+import 'change-case';
+import 'node:path';
+import 'node:buffer';
+import 'node:util';
+import 'chalk';
+import 'polytype';
+import 'typescript';
+import 'tslib';
+import 'crypto';
+import 'fs';
+import 'os';
+import 'cross-spawn';
+//# sourceMappingURL=run-cli.mjs.map

package/bin/run-cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}

package/cli.d.ts

@@ -0,0 +1 @@
+export {};