@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

package/dist/compiler/tir/statements/TirVarDecl/TirSimpleVarDecl.js

@@ -1,22 +0,0 @@
-export class TirSimpleVarDecl {
-    name;
-    type;
-    initExpr;
-    isConst;
-    range;
-    constructor(name, type, initExpr, // deconstructed OR function param
-    isConst, range) {
-        this.name = name;
-        this.type = type;
-        this.initExpr = initExpr;
-        this.isConst = isConst;
-        this.range = range;
-    }
-    deps() {
-        return this.initExpr?.deps() ?? [];
-    }
-    definitelyTerminates() { return false; }
-    introducedVars() {
-        return [this.name];
-    }
-}

package/dist/compiler/tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.d.ts

@@ -1,17 +0,0 @@
-import { SourceRange } from "../../../../ast/Source/SourceRange.js";
-import { TirExpr } from "../../expressions/TirExpr.js";
-import { TirType } from "../../types/TirType.js";
-import { ITirStmt } from "../TirStmt.js";
-import { TirVarDecl } from "./TirVarDecl.js";
-export declare class TirSingleDeconstructVarDecl implements ITirStmt {
-    readonly fields: Map<string, TirVarDecl>;
-    readonly rest: string | undefined;
-    readonly type: TirType;
-    initExpr: TirExpr | undefined;
-    isConst: boolean;
-    readonly range: SourceRange;
-    constructor(fields: Map<string, TirVarDecl>, rest: string | undefined, type: TirType, initExpr: TirExpr | undefined, isConst: boolean, range: SourceRange);
-    deps(): string[];
-    definitelyTerminates(): boolean;
-    introducedVars(): string[];
-}

package/dist/compiler/tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js

@@ -1,30 +0,0 @@
-import { mergeSortedStrArrInplace } from "../../../../utils/array/mergeSortedStrArrInplace.js";
-export class TirSingleDeconstructVarDecl {
-    fields;
-    rest;
-    type;
-    initExpr;
-    isConst;
-    range;
-    constructor(fields, rest, type, initExpr, isConst, range) {
-        this.fields = fields;
-        this.rest = rest;
-        this.type = type;
-        this.initExpr = initExpr;
-        this.isConst = isConst;
-        this.range = range;
-    }
-    deps() {
-        return this.initExpr?.deps() ?? [];
-    }
-    definitelyTerminates() { return false; }
-    introducedVars() {
-        const introducedVars = [];
-        for (const field of this.fields.values()) {
-            mergeSortedStrArrInplace(introducedVars, field.introducedVars());
-        }
-        if (this.rest)
-            mergeSortedStrArrInplace(introducedVars, [this.rest]);
-        return introducedVars;
-    }
-}

package/dist/compiler/tir/statements/TirVarDecl/TirVarDecl.d.ts

@@ -1,10 +0,0 @@
-import { TirNamedDeconstructVarDecl } from "./TirNamedDeconstructVarDecl.js";
-import { TirSimpleVarDecl } from "./TirSimpleVarDecl.js";
-import { TirSingleDeconstructVarDecl } from "./TirSingleDeconstructVarDecl.js";
-import { TirArrayLikeDeconstr } from "./TirArrayLikeDeconstr.js";
-export interface ITirVarDecl {
-    introducedVars: () => string[];
-    readonly isConst: boolean;
-}
-export type TirVarDecl = TirSimpleVarDecl | TirNamedDeconstructVarDecl | TirSingleDeconstructVarDecl | TirArrayLikeDeconstr;
-export declare function isTirVarDecl(thing: any): thing is TirVarDecl;

package/dist/compiler/tir/statements/TirVarDecl/TirVarDecl.js

@@ -1,11 +0,0 @@
-import { TirNamedDeconstructVarDecl } from "./TirNamedDeconstructVarDecl.js";
-import { TirSimpleVarDecl } from "./TirSimpleVarDecl.js";
-import { TirSingleDeconstructVarDecl } from "./TirSingleDeconstructVarDecl.js";
-import { TirArrayLikeDeconstr } from "./TirArrayLikeDeconstr.js";
-import { isObject } from "@harmoniclabs/obj-utils";
-export function isTirVarDecl(thing) {
-    return isObject(thing) && (thing instanceof TirSimpleVarDecl
-        || thing instanceof TirNamedDeconstructVarDecl
-        || thing instanceof TirSingleDeconstructVarDecl
-        || thing instanceof TirArrayLikeDeconstr);
-}

package/dist/compiler/tir/statements/TirWhileStmt.d.ts

@@ -1,11 +0,0 @@
-import { SourceRange } from "../../../ast/Source/SourceRange.js";
-import { TirExpr } from "../expressions/TirExpr.js";
-import { ITirStmt, TirStmt } from "./TirStmt.js";
-export declare class TirWhileStmt implements ITirStmt {
-    readonly condition: TirExpr;
-    body: TirStmt;
-    readonly range: SourceRange;
-    constructor(condition: TirExpr, body: TirStmt, range: SourceRange);
-    definitelyTerminates(): boolean;
-    deps(): string[];
-}

package/dist/compiler/tir/statements/TirWhileStmt.js

@@ -1,19 +0,0 @@
-export class TirWhileStmt {
-    condition;
-    body;
-    range;
-    constructor(condition, body, range) {
-        this.condition = condition;
-        this.body = body;
-        this.range = range;
-    }
-    definitelyTerminates() {
-        return this.body.definitelyTerminates();
-    }
-    deps() {
-        return [
-            ...new Set(this.condition.deps()
-                .concat(this.body.deps()))
-        ];
-    }
-}

package/dist/compiler/tir/statements/utils/definitelyFails.d.ts

@@ -1,3 +0,0 @@
-import { TirBlockStmt } from "../TirBlockStmt.js";
-import { TirStmt } from "../TirStmt.js";
-export declare function definitelyFails(stmt: TirStmt | TirBlockStmt): boolean;

package/dist/compiler/tir/statements/utils/definitelyFails.js

@@ -1,52 +0,0 @@
-import { TirAssertStmt } from "../TirAssertStmt.js";
-import { TirAssignmentStmt } from "../TirAssignmentStmt.js";
-import { TirBlockStmt } from "../TirBlockStmt.js";
-import { TirBreakStmt } from "../TirBreakStmt.js";
-import { TirContinueStmt } from "../TirContinueStmt.js";
-import { TirFailStmt } from "../TirFailStmt.js";
-import { TirForOfStmt } from "../TirForOfStmt.js";
-import { TirForStmt } from "../TirForStmt.js";
-import { TirIfStmt } from "../TirIfStmt.js";
-import { TirMatchStmt } from "../TirMatchStmt.js";
-import { TirReturnStmt } from "../TirReturnStmt.js";
-import { isTirVarDecl } from "../TirVarDecl/TirVarDecl.js";
-import { TirWhileStmt } from "../TirWhileStmt.js";
-export function definitelyFails(stmt) {
-    const stack = [stmt];
-    while (stmt = stack.pop()) {
-        if (stmt instanceof TirFailStmt)
-            return true;
-        if (stmt instanceof TirBlockStmt) {
-            stack.push(...stmt.stmts);
-            continue;
-        }
-        if (isTirVarDecl(stmt))
-            continue;
-        if (stmt instanceof TirIfStmt) {
-            stack.push(stmt.thenBranch);
-            if (stmt.elseBranch)
-                stack.push(stmt.elseBranch);
-            continue;
-        }
-        if (stmt instanceof TirMatchStmt) {
-            if (stmt.cases.every(({ body }) => definitelyFails(body)))
-                return true;
-            continue;
-        }
-        if (stmt instanceof TirForStmt
-            || stmt instanceof TirForOfStmt
-            || stmt instanceof TirWhileStmt) {
-            stack.push(stmt.body);
-            continue;
-        }
-        if (stmt instanceof TirReturnStmt
-            || stmt instanceof TirBlockStmt
-            || stmt instanceof TirBreakStmt
-            || stmt instanceof TirContinueStmt
-            || stmt instanceof TirAssertStmt
-            || stmt instanceof TirAssignmentStmt)
-            continue;
-        // const tsEnsureExsaustiveCheck: never = stmt;
-    }
-    return false;
-}

package/dist/compiler/tir/types/TirAliasType.d.ts

@@ -1,32 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { AstFuncName, TirFuncName } from "../../AstCompiler/scope/AstScope.js";
-import { ITirType, TirType } from "./TirType.js";
-export declare class TirAliasType<AliasedT extends TirType = TirType> implements ITirType {
-    readonly name: string;
-    readonly fileUid: string;
-    readonly aliased: AliasedT;
-    /**
-     * Maps AstFuncName to TirFuncName for methods defined in this alias type.
-     * This is used to resolve method calls on the aliased type.
-     *
-     * @type {Map<AstFuncName, TirFuncName>}
-     */
-    readonly methodsNamesPtr: Map<AstFuncName, TirFuncName>;
-    constructor(name: string, fileUid: string, aliased: AliasedT, 
-    /**
-     * Maps AstFuncName to TirFuncName for methods defined in this alias type.
-     * This is used to resolve method calls on the aliased type.
-     *
-     * @type {Map<AstFuncName, TirFuncName>}
-     */
-    methodsNamesPtr: Map<AstFuncName, TirFuncName>);
-    hasDataEncoding(): boolean;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    toString(): string;
-    toAstName(): string;
-    private _isConcrete;
-    isConcrete(): boolean;
-    clone(): TirAliasType<AliasedT>;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirAliasType.js

@@ -1,49 +0,0 @@
-export class TirAliasType {
-    name;
-    fileUid;
-    aliased;
-    methodsNamesPtr;
-    constructor(name, fileUid, aliased, 
-    /**
-     * Maps AstFuncName to TirFuncName for methods defined in this alias type.
-     * This is used to resolve method calls on the aliased type.
-     *
-     * @type {Map<AstFuncName, TirFuncName>}
-     */
-    methodsNamesPtr) {
-        this.name = name;
-        this.fileUid = fileUid;
-        this.aliased = aliased;
-        this.methodsNamesPtr = methodsNamesPtr;
-    }
-    hasDataEncoding() {
-        return this.aliased.hasDataEncoding();
-    }
-    toTirTypeKey() {
-        return this.name + "_" + this.fileUid;
-    }
-    toConcreteTirTypeName() {
-        return this.toTirTypeKey();
-    }
-    toString() {
-        return this.name;
-    }
-    toAstName() {
-        return this.toString();
-    }
-    _isConcrete = undefined;
-    isConcrete() {
-        if (typeof this._isConcrete !== "boolean")
-            this._isConcrete = this.aliased.isConcrete();
-        return this._isConcrete;
-    }
-    clone() {
-        return new TirAliasType(this.name, this.fileUid, this.aliased.clone(), this.methodsNamesPtr);
-    }
-    toUplcConstType() {
-        let t = this.aliased;
-        while (t instanceof TirAliasType)
-            t = t.aliased;
-        return t.toUplcConstType();
-    }
-}

package/dist/compiler/tir/types/TirInterfaceImpl.d.ts

@@ -1,44 +0,0 @@
-import { TirInterfaceType } from "./TirInterfaceType.js";
-import { TirCustomType } from "./TirType.js";
-export declare class TirInterfaceImpl {
-    /**
-     * type that implements the interface
-     */
-    readonly thisType: TirCustomType;
-    /**
-     * interface type being implemented
-     *
-     * `undefined` for anonymous interfaces
-     * eg. `type MyType implements { ... }`
-     */
-    readonly interfaceType: TirInterfaceType | undefined;
-    /**
-     * method implementations are
-     * compiled as functions external to the type being implemented
-     *
-     * here we map the `frontendName`
-     * to the external function ast name stored in the scope
-     */
-    readonly methodImplExternalFunctionName: Map<string, string>;
-    constructor(
-    /**
-     * type that implements the interface
-     */
-    thisType: TirCustomType, 
-    /**
-     * interface type being implemented
-     *
-     * `undefined` for anonymous interfaces
-     * eg. `type MyType implements { ... }`
-     */
-    interfaceType: TirInterfaceType | undefined, 
-    /**
-     * method implementations are
-     * compiled as functions external to the type being implemented
-     *
-     * here we map the `frontendName`
-     * to the external function ast name stored in the scope
-     */
-    methodImplExternalFunctionName: Map<string, string>);
-    clone(): TirInterfaceImpl;
-}

package/dist/compiler/tir/types/TirInterfaceImpl.js

@@ -1,32 +0,0 @@
-export class TirInterfaceImpl {
-    thisType;
-    interfaceType;
-    methodImplExternalFunctionName;
-    constructor(
-    /**
-     * type that implements the interface
-     */
-    thisType, 
-    /**
-     * interface type being implemented
-     *
-     * `undefined` for anonymous interfaces
-     * eg. `type MyType implements { ... }`
-     */
-    interfaceType, 
-    /**
-     * method implementations are
-     * compiled as functions external to the type being implemented
-     *
-     * here we map the `frontendName`
-     * to the external function ast name stored in the scope
-     */
-    methodImplExternalFunctionName) {
-        this.thisType = thisType;
-        this.interfaceType = interfaceType;
-        this.methodImplExternalFunctionName = methodImplExternalFunctionName;
-    }
-    clone() {
-        return new TirInterfaceImpl(this.thisType, this.interfaceType?.clone(), new Map(this.methodImplExternalFunctionName));
-    }
-}

package/dist/compiler/tir/types/TirInterfaceType.d.ts

@@ -1,28 +0,0 @@
-import { TirFuncT } from "./TirNativeType/native/function.js";
-/**
- * represents interface declaraions
- */
-export declare class TirInterfaceType {
-    readonly name: string;
-    readonly methods: TirInterfaceMethod[];
-    constructor(name: string, methods: TirInterfaceMethod[]);
-    clone(): TirInterfaceType;
-}
-/**
- * only represents the method signature declared in the interface
- *
- * this is not the method implementation
- */
-export declare class TirInterfaceMethod {
-    /**
-     * method name used by the developer
-     */
-    readonly frontendName: string;
-    readonly funcSingature: TirFuncT;
-    constructor(
-    /**
-     * method name used by the developer
-     */
-    frontendName: string, funcSingature: TirFuncT);
-    clone(): TirInterfaceMethod;
-}

package/dist/compiler/tir/types/TirInterfaceType.js

@@ -1,36 +0,0 @@
-/**
- * represents interface declaraions
- */
-export class TirInterfaceType {
-    name;
-    methods;
-    constructor(
-    // anonymous interface for custom type methods
-    name, methods) {
-        this.name = name;
-        this.methods = methods;
-    }
-    clone() {
-        return new TirInterfaceType(this.name, this.methods.map(m => m.clone()));
-    }
-}
-/**
- * only represents the method signature declared in the interface
- *
- * this is not the method implementation
- */
-export class TirInterfaceMethod {
-    frontendName;
-    funcSingature;
-    constructor(
-    /**
-     * method name used by the developer
-     */
-    frontendName, funcSingature) {
-        this.frontendName = frontendName;
-        this.funcSingature = funcSingature;
-    }
-    clone() {
-        return new TirInterfaceMethod(this.frontendName, this.funcSingature.clone());
-    }
-}

package/dist/compiler/tir/types/TirNativeType/TirNativeType.d.ts

@@ -1,41 +0,0 @@
-import type { ITirType, TirType } from "../TirType.js";
-import { ConstType } from "@harmoniclabs/uplc";
-import { TirBoolT } from "./native/bool.js";
-import { TirBytesT } from "./native/bytes.js";
-import { TirDataT } from "./native/data.js";
-import { TirFuncT } from "./native/function.js";
-import { TirIntT } from "./native/int.js";
-import { TirLinearMapT } from "./native/linearMap.js";
-import { TirListT } from "./native/list.js";
-import { TirDataOptT } from "./native/Optional/data.js";
-import { TirSopOptT } from "./native/Optional/sop.js";
-import { TirStringT } from "./native/string.js";
-import { TirVoidT } from "./native/void.js";
-export type TirNamedDestructableNativeType = TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType>;
-export declare function isTirNamedDestructableNativeType(t: any): t is TirNamedDestructableNativeType;
-export type TirNativeType = TirVoidT | TirBoolT | TirIntT | TirBytesT | TirStringT | TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType> | TirFuncT | TirUnConstrDataResultT | TirPairDataT;
-export declare function isTirNativeType(t: any): t is TirNativeType;
-export declare class TirUnConstrDataResultT implements ITirType {
-    constructor();
-    hasDataEncoding(): boolean;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    toString(): string;
-    toAstName(): string;
-    isConcrete(): boolean;
-    clone(): TirUnConstrDataResultT;
-    toUplcConstType(): ConstType;
-}
-export declare class TirPairDataT implements ITirType {
-    constructor();
-    hasDataEncoding(): boolean;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    toString(): string;
-    toAstName(): string;
-    isConcrete(): boolean;
-    clone(): TirPairDataT;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/TirNativeType.js

@@ -1,86 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-import { TirBoolT } from "./native/bool.js";
-import { TirBytesT } from "./native/bytes.js";
-import { TirDataT } from "./native/data.js";
-import { TirFuncT } from "./native/function.js";
-import { TirIntT } from "./native/int.js";
-import { TirLinearMapT } from "./native/linearMap.js";
-import { TirListT } from "./native/list.js";
-import { TirDataOptT } from "./native/Optional/data.js";
-import { TirSopOptT } from "./native/Optional/sop.js";
-import { TirStringT } from "./native/string.js";
-import { TirVoidT } from "./native/void.js";
-export function isTirNamedDestructableNativeType(t) {
-    return (t instanceof TirDataT
-        || t instanceof TirDataOptT
-        || t instanceof TirSopOptT
-        || t instanceof TirListT
-        || t instanceof TirLinearMapT);
-}
-export function isTirNativeType(t) {
-    return (t instanceof TirVoidT
-        || t instanceof TirBoolT
-        || t instanceof TirIntT
-        || t instanceof TirBytesT
-        || t instanceof TirStringT
-        || t instanceof TirDataT
-        || t instanceof TirDataOptT
-        || t instanceof TirSopOptT
-        || t instanceof TirListT
-        || t instanceof TirLinearMapT
-        || t instanceof TirFuncT // =>
-        || t instanceof TirUnConstrDataResultT
-        || t instanceof TirPairDataT);
-}
-export class TirUnConstrDataResultT {
-    constructor() { }
-    hasDataEncoding() { return false; }
-    static toTirTypeKey() {
-        return "#un_constr_data_result#";
-    }
-    toTirTypeKey() {
-        return TirUnConstrDataResultT.toTirTypeKey();
-    }
-    toConcreteTirTypeName() {
-        return this.toTirTypeKey();
-    }
-    toString() {
-        return this.toTirTypeKey();
-    }
-    toAstName() {
-        return this.toTirTypeKey();
-    }
-    isConcrete() { return true; }
-    clone() {
-        return new TirUnConstrDataResultT();
-    }
-    toUplcConstType() {
-        return constT.pairOf(constT.int, constT.listOf(constT.data));
-    }
-}
-export class TirPairDataT {
-    constructor() { }
-    hasDataEncoding() { return false; }
-    static toTirTypeKey() {
-        return "#pair_data";
-    }
-    toTirTypeKey() {
-        return TirPairDataT.toTirTypeKey();
-    }
-    toConcreteTirTypeName() {
-        return this.toTirTypeKey();
-    }
-    toString() {
-        return this.toTirTypeKey();
-    }
-    toAstName() {
-        return this.toTirTypeKey();
-    }
-    isConcrete() { return true; }
-    clone() {
-        return new TirPairDataT();
-    }
-    toUplcConstType() {
-        return constT.pairOf(constT.data, constT.data);
-    }
-}

package/dist/compiler/tir/types/TirNativeType/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./TirNativeType.js";
-export * from "./native/index.js";

package/dist/compiler/tir/types/TirNativeType/index.js

@@ -1,2 +0,0 @@
-export * from "./TirNativeType.js";
-export * from "./native/index.js";

package/dist/compiler/tir/types/TirNativeType/native/Optional/data.d.ts

@@ -1,17 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { TirDataStructType } from "../../../TirStructType.js";
-import { TirType, ITirType } from "../../../TirType.js";
-export declare class TirDataOptT<T extends TirType = TirType> extends TirDataStructType implements ITirType {
-    readonly typeArg: T;
-    constructor(typeArg: T);
-    hasDataEncoding(): boolean;
-    toAstName(): string;
-    toString(): string;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    protected _isConcrete: boolean | undefined;
-    isConcrete(): boolean;
-    clone(): TirDataOptT<T>;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/Optional/data.js

@@ -1,47 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-import { getAppliedTirTypeName } from "../../../../program/TypedProgram.js";
-import { TirDataStructType, TirStructConstr, TirStructField } from "../../../TirStructType.js";
-export class TirDataOptT extends TirDataStructType {
-    typeArg;
-    constructor(typeArg) {
-        super("Optional", // name
-        "", // fileUid
-        [
-            new TirStructConstr("Some", // name
-            [
-                new TirStructField("value", typeArg)
-            ]),
-            new TirStructConstr("None", []) // name, fields
-        ], new Map() // methodNamesPtr
-        );
-        this.typeArg = typeArg;
-    }
-    hasDataEncoding() { return this.typeArg.hasDataEncoding(); }
-    toAstName() {
-        return "Optional";
-    }
-    toString() {
-        return `${this.toAstName()}<${this.typeArg.toString()}>`;
-    }
-    static toTirTypeKey() {
-        return "data_opt";
-    }
-    toTirTypeKey() {
-        return TirDataOptT.toTirTypeKey();
-    }
-    toConcreteTirTypeName() {
-        return getAppliedTirTypeName(this.toTirTypeKey(), [this.typeArg.toConcreteTirTypeName()]);
-    }
-    _isConcrete = undefined;
-    isConcrete() {
-        if (typeof this._isConcrete !== "boolean")
-            this._isConcrete = this.typeArg.isConcrete();
-        return this._isConcrete;
-    }
-    clone() {
-        const result = new TirDataOptT(this.typeArg.clone());
-        result._isConcrete = this._isConcrete;
-        return result;
-    }
-    toUplcConstType() { return constT.data; }
-}

package/dist/compiler/tir/types/TirNativeType/native/Optional/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./data.js";
-export * from "./sop.js";
-export * from "./isTirOptType.js";

package/dist/compiler/tir/types/TirNativeType/native/Optional/index.js

@@ -1,3 +0,0 @@
-export * from "./data.js";
-export * from "./sop.js";
-export * from "./isTirOptType.js";

package/dist/compiler/tir/types/TirNativeType/native/Optional/isTirOptType.d.ts

@@ -1,4 +0,0 @@
-import { TirType } from "../../../TirType.js";
-import { TirDataOptT } from "./data.js";
-import { TirSopOptT } from "./sop.js";
-export declare function isTirOptType(t: any): t is TirDataOptT<TirType> | TirSopOptT<TirType>;

package/dist/compiler/tir/types/TirNativeType/native/Optional/isTirOptType.js

@@ -1,6 +0,0 @@
-import { TirDataOptT } from "./data.js";
-import { TirSopOptT } from "./sop.js";
-export function isTirOptType(t) {
-    return (t instanceof TirDataOptT
-        || t instanceof TirSopOptT);
-}

package/dist/compiler/tir/types/TirNativeType/native/Optional/sop.d.ts

@@ -1,17 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { TirSoPStructType } from "../../../TirStructType.js";
-import { TirType, ITirType } from "../../../TirType.js";
-export declare class TirSopOptT<T extends TirType = TirType> extends TirSoPStructType implements ITirType {
-    readonly typeArg: T;
-    constructor(typeArg: T);
-    hasDataEncoding(): boolean;
-    toAstName(): string;
-    toString(): string;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    protected _isConcrete: boolean | undefined;
-    isConcrete(): boolean;
-    clone(): TirSopOptT<T>;
-    toUplcConstType(): ConstType;
-}