@algorandfoundation/algokit-client-generator 2.6.0-beta.1 → 2.6.1-beta.1

package/client/{call-client.js → call-client.mjs}

@@ -1,62 +1,37 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callClient = void 0;
-const algokit = __importStar(require("@algorandfoundation/algokit-utils"));
-const writer_1 = require("../output/writer");
-const sanitization_1 = require("../util/sanitization");
-const get_call_config_summary_1 = require("./helpers/get-call-config-summary");
-const deploy_types_1 = require("./deploy-types");
-const call_composer_1 = require("./call-composer");
+import * as algokit from '@algorandfoundation/algokit-utils';
+import { jsDoc, IncIndent, NewLine, indent, DecIndent, inline, DecIndentAndCloseBlock } from '../output/writer.mjs';
+import { makeSafeTypeIdentifier, makeSafeMethodIdentifier } from '../util/sanitization.mjs';
+import { BARE_CALL } from './helpers/get-call-config-summary.mjs';
+import { getCreateOnCompleteOptions } from './deploy-types.mjs';
+import { composeMethod } from './call-composer.mjs';
+
 function* callClient(ctx) {
     const { app, name } = ctx;
-    yield* (0, writer_1.jsDoc)(`A client to make calls to the ${app.contract.name} smart contract`);
-    yield `export class ${(0, sanitization_1.makeSafeTypeIdentifier)(app.contract.name)}Client {`;
-    yield writer_1.IncIndent;
-    yield* (0, writer_1.jsDoc)(`The underlying \`ApplicationClient\` for when you want to have more flexibility`);
+    yield* jsDoc(`A client to make calls to the ${app.contract.name} smart contract`);
+    yield `export class ${makeSafeTypeIdentifier(app.contract.name)}Client {`;
+    yield IncIndent;
+    yield* jsDoc(`The underlying \`ApplicationClient\` for when you want to have more flexibility`);
     yield 'public readonly appClient: ApplicationClient';
-    yield writer_1.NewLine;
+    yield NewLine;
     yield `private readonly sender: SendTransactionFrom | undefined`;
-    yield writer_1.NewLine;
-    yield* (0, writer_1.jsDoc)({
-        description: `Creates a new instance of \`${(0, sanitization_1.makeSafeTypeIdentifier)(app.contract.name)}Client\``,
+    yield NewLine;
+    yield* jsDoc({
+        description: `Creates a new instance of \`${makeSafeTypeIdentifier(app.contract.name)}Client\``,
         params: {
             appDetails: 'appDetails The details to identify the app to deploy',
             algod: 'An algod client instance',
         },
     });
     yield `constructor(appDetails: AppDetails, private algod: Algodv2) {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield `this.sender = appDetails.sender`;
     yield 'this.appClient = algokit.getAppClient({';
-    yield* (0, writer_1.indent)('...appDetails,', 'app: APP_SPEC');
+    yield* indent('...appDetails,', 'app: APP_SPEC');
     yield '}, algod)';
-    yield writer_1.DecIndent;
+    yield DecIndent;
     yield '}';
-    yield writer_1.NewLine;
-    yield* (0, writer_1.jsDoc)({
+    yield NewLine;
+    yield* jsDoc({
         description: 'Checks for decode errors on the AppCallTransactionResult and maps the return value to the specified generic type',
         params: {
             result: 'The AppCallTransactionResult to be mapped',
@@ -64,20 +39,20 @@ function* callClient(ctx) {
         },
         returns: 'The smart contract response with an updated return value',
     });
-    yield* (0, writer_1.inline)(`protected mapReturnValue<TReturn, TResult extends AppCallTransactionResult = AppCallTransactionResult>`, `(result: AppCallTransactionResult, returnValueFormatter?: (value: any) => TReturn): `, `AppCallTransactionResultOfType<TReturn> & TResult {`);
-    yield writer_1.IncIndent;
+    yield* inline(`protected mapReturnValue<TReturn, TResult extends AppCallTransactionResult = AppCallTransactionResult>`, `(result: AppCallTransactionResult, returnValueFormatter?: (value: any) => TReturn): `, `AppCallTransactionResultOfType<TReturn> & TResult {`);
+    yield IncIndent;
     yield `if(result.return?.decodeError) {`;
-    yield* (0, writer_1.indent)(`throw result.return.decodeError`);
+    yield* indent(`throw result.return.decodeError`);
     yield `}`;
     yield `const returnValue = result.return?.returnValue !== undefined && returnValueFormatter !== undefined`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield `? returnValueFormatter(result.return.returnValue)`;
     yield `: result.return?.returnValue as TReturn | undefined`;
     yield `return { ...result, return: returnValue } as AppCallTransactionResultOfType<TReturn> & TResult`;
-    yield writer_1.DecIndent;
-    yield writer_1.DecIndentAndCloseBlock;
-    yield writer_1.NewLine;
-    yield* (0, writer_1.jsDoc)({
+    yield DecIndent;
+    yield DecIndentAndCloseBlock;
+    yield NewLine;
+    yield* jsDoc({
         description: 'Calls the ABI method with the matching signature using an onCompletion code of NO_OP',
         params: {
             typedCallParams: 'An object containing the method signature, args, and any other relevant parameters',
@@ -86,21 +61,20 @@ function* callClient(ctx) {
         returns: 'The result of the smart contract call',
     });
     yield `public async call<TSignature extends keyof ${name}['methods']>(typedCallParams: TypedCallParams<TSignature>, returnValueFormatter?: (value: any) => MethodReturn<TSignature>) {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield `return this.mapReturnValue<MethodReturn<TSignature>>(await this.appClient.call(typedCallParams), returnValueFormatter)`;
-    yield writer_1.DecIndentAndCloseBlock;
-    yield writer_1.NewLine;
+    yield DecIndentAndCloseBlock;
+    yield NewLine;
     yield* opMethods(ctx);
     yield* clearState(ctx);
     yield* noopMethods(ctx);
     yield* getStateMethods(ctx);
-    yield* (0, call_composer_1.composeMethod)(ctx);
-    yield writer_1.DecIndentAndCloseBlock;
+    yield* composeMethod(ctx);
+    yield DecIndentAndCloseBlock;
 }
-exports.callClient = callClient;
 function* opMethods(ctx) {
     const { app, callConfig, name } = ctx;
-    yield* (0, writer_1.jsDoc)({
+    yield* jsDoc({
         description: `Idempotently deploys the ${app.contract.name} smart contract.`,
         params: {
             params: 'The arguments for the contract calls and any additional parameters for the call',
@@ -108,7 +82,7 @@ function* opMethods(ctx) {
         returns: 'The deployment result',
     });
     yield `public deploy(params: ${name}DeployArgs & AppClientDeployCoreParams = {}): ReturnType<ApplicationClient['deploy']> {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     if (callConfig.createMethods.length)
         yield `const createArgs = params.createCall?.(${name}CallFactory.create)`;
     if (callConfig.updateMethods.length)
@@ -116,7 +90,7 @@ function* opMethods(ctx) {
     if (callConfig.deleteMethods.length)
         yield `const deleteArgs = params.deleteCall?.(${name}CallFactory.delete)`;
     yield `return this.appClient.deploy({`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield `...params,`;
     if (callConfig.updateMethods.length)
         yield 'updateArgs,';
@@ -126,10 +100,10 @@ function* opMethods(ctx) {
         yield 'createArgs,';
         yield `createOnCompleteAction: createArgs?.onCompleteAction,`;
     }
-    yield writer_1.DecIndent;
+    yield DecIndent;
     yield `})`;
-    yield writer_1.DecIndentAndCloseBlock;
-    yield writer_1.NewLine;
+    yield DecIndentAndCloseBlock;
+    yield NewLine;
     yield* operationMethod(ctx, `Creates a new instance of the ${app.contract.name} smart contract`, callConfig.createMethods, 'create', true);
     yield* operationMethod(ctx, `Updates an existing instance of the ${app.contract.name} smart contract`, callConfig.updateMethods, 'update', true);
     yield* operationMethod(ctx, `Deletes an existing instance of the ${app.contract.name} smart contract`, callConfig.deleteMethods, 'delete');
@@ -137,7 +111,6 @@ function* opMethods(ctx) {
     yield* operationMethod(ctx, `Makes a close out call to an existing instance of the ${app.contract.name} smart contract`, callConfig.closeOutMethods, 'closeOut');
 }
 function* operationMethod({ app, methodSignatureToUniqueName, name }, description, methods, verb, includeCompilation) {
-    var _a;
     let responseTypeGenericParam;
     switch (verb) {
         case 'create':
@@ -151,49 +124,49 @@ function* operationMethod({ app, methodSignatureToUniqueName, name }, descriptio
             break;
     }
     if (methods.length) {
-        yield* (0, writer_1.jsDoc)(`Gets available ${verb} methods`);
+        yield* jsDoc(`Gets available ${verb} methods`);
         yield `public get ${verb}() {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         yield `const $this = this`;
         yield `return {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         for (const methodSig of methods) {
-            const onComplete = verb === 'create' ? (0, deploy_types_1.getCreateOnCompleteOptions)(methodSig, app) : undefined;
-            if (methodSig === get_call_config_summary_1.BARE_CALL) {
-                yield* (0, writer_1.jsDoc)({
+            const onComplete = verb === 'create' ? getCreateOnCompleteOptions(methodSig, app) : undefined;
+            if (methodSig === BARE_CALL) {
+                yield* jsDoc({
                     description: `${description} using a bare call.`,
                     params: {
                         args: `The arguments for the bare call`,
                     },
                     returns: `The ${verb} result`,
                 });
-                yield `async bare(args: BareCallArgs & AppClientCallCoreParams ${includeCompilation ? '& AppClientCompilationParams ' : ''}& CoreAppCallArgs${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.type) ? ` & ${onComplete.type}` : ''}${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.isOptional) !== false ? ' = {}' : ''}) {`;
-                yield* (0, writer_1.indent)(`return $this.mapReturnValue<undefined${responseTypeGenericParam}>(await $this.appClient.${verb}(args))`);
+                yield `async bare(args: BareCallArgs & AppClientCallCoreParams ${includeCompilation ? '& AppClientCompilationParams ' : ''}& CoreAppCallArgs${onComplete?.type ? ` & ${onComplete.type}` : ''}${onComplete?.isOptional !== false ? ' = {}' : ''}) {`;
+                yield* indent(`return $this.mapReturnValue<undefined${responseTypeGenericParam}>(await $this.appClient.${verb}(args))`);
                 yield '},';
             }
             else {
                 const uniqueName = methodSignatureToUniqueName[methodSig];
                 const method = app.contract.methods.find((m) => algokit.getABIMethodSignature(m) === methodSig);
-                yield* (0, writer_1.jsDoc)({
+                yield* jsDoc({
                     description: `${description} using the ${methodSig} ABI method.`,
                     params: {
                         args: `The arguments for the smart contract call`,
                         params: `Any additional parameters for the call`,
                     },
-                    returns: `The ${verb} result${((_a = method === null || method === void 0 ? void 0 : method.returns) === null || _a === void 0 ? void 0 : _a.desc) ? `: ${method.returns.desc}` : ''}`,
+                    returns: `The ${verb} result${method?.returns?.desc ? `: ${method.returns.desc}` : ''}`,
                 });
-                yield `async ${(0, sanitization_1.makeSafeMethodIdentifier)(uniqueName)}(args: MethodArgs<'${methodSig}'>, params: AppClientCallCoreParams${includeCompilation ? ' & AppClientCompilationParams' : ''}${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.type) ? ` & ${onComplete.type}` : ''}${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.isOptional) !== false ? ' = {}' : ''}) {`;
-                yield* (0, writer_1.indent)(`return $this.mapReturnValue<MethodReturn<'${methodSig}'>${responseTypeGenericParam}>(await $this.appClient.${verb}(${name}CallFactory.${verb}.${(0, sanitization_1.makeSafeMethodIdentifier)(uniqueName)}(args, params)))`);
+                yield `async ${makeSafeMethodIdentifier(uniqueName)}(args: MethodArgs<'${methodSig}'>, params: AppClientCallCoreParams${includeCompilation ? ' & AppClientCompilationParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}${onComplete?.isOptional !== false ? ' = {}' : ''}) {`;
+                yield* indent(`return $this.mapReturnValue<MethodReturn<'${methodSig}'>${responseTypeGenericParam}>(await $this.appClient.${verb}(${name}CallFactory.${verb}.${makeSafeMethodIdentifier(uniqueName)}(args, params)))`);
                 yield '},';
             }
         }
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.NewLine;
+        yield DecIndentAndCloseBlock;
+        yield DecIndentAndCloseBlock;
+        yield NewLine;
     }
 }
 function* clearState({ app }) {
-    yield* (0, writer_1.jsDoc)({
+    yield* jsDoc({
         description: `Makes a clear_state call to an existing instance of the ${app.contract.name} smart contract.`,
         params: {
             args: `The arguments for the bare call`,
@@ -201,43 +174,41 @@ function* clearState({ app }) {
         returns: `The clear_state result`,
     });
     yield `public clearState(args: BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs = {}) {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield `return this.appClient.clearState(args)`;
-    yield writer_1.DecIndentAndCloseBlock;
-    yield writer_1.NewLine;
+    yield DecIndentAndCloseBlock;
+    yield NewLine;
 }
 function* noopMethods({ app, name, callConfig, methodSignatureToUniqueName }) {
-    var _a, _b, _c, _d, _e;
     for (const method of app.contract.methods) {
         const methodSignature = algokit.getABIMethodSignature(method);
-        const methodName = (0, sanitization_1.makeSafeMethodIdentifier)(methodSignatureToUniqueName[methodSignature]);
+        const methodName = makeSafeMethodIdentifier(methodSignatureToUniqueName[methodSignature]);
         // Skip methods which don't support a no_op call config
         if (!callConfig.callMethods.includes(methodSignature))
             continue;
-        yield* (0, writer_1.jsDoc)({
+        yield* jsDoc({
             description: `Calls the ${algokit.getABIMethodSignature(method)} ABI method.`,
             abiDescription: method.desc,
             params: {
                 args: `The arguments for the contract call`,
                 params: `Any additional parameters for the call`,
             },
-            returns: `The result of the call${((_a = method === null || method === void 0 ? void 0 : method.returns) === null || _a === void 0 ? void 0 : _a.desc) ? `: ${method.returns.desc}` : ''}`,
+            returns: `The result of the call${method?.returns?.desc ? `: ${method.returns.desc}` : ''}`,
         });
         yield `public ${methodName}(args: MethodArgs<'${methodSignature}'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) {`;
-        yield writer_1.IncIndent;
-        const outputTypeName = (_e = (_d = (_c = (_b = app.hints) === null || _b === void 0 ? void 0 : _b[methodSignature]) === null || _c === void 0 ? void 0 : _c.structs) === null || _d === void 0 ? void 0 : _d.output) === null || _e === void 0 ? void 0 : _e.name;
-        yield `return this.call(${name}CallFactory.${methodName}(args, params)${outputTypeName === undefined ? '' : `, ${(0, sanitization_1.makeSafeTypeIdentifier)(outputTypeName)}`})`;
-        yield writer_1.DecIndent;
+        yield IncIndent;
+        const outputTypeName = app.hints?.[methodSignature]?.structs?.output?.name;
+        yield `return this.call(${name}CallFactory.${methodName}(args, params)${outputTypeName === undefined ? '' : `, ${makeSafeTypeIdentifier(outputTypeName)}`})`;
+        yield DecIndent;
         yield '}';
-        yield writer_1.NewLine;
+        yield NewLine;
     }
 }
 function* getStateMethods({ app, name }) {
-    var _a, _b, _c, _d;
-    const globalStateValues = ((_a = app.schema.global) === null || _a === void 0 ? void 0 : _a.declared) && Object.values((_b = app.schema.global) === null || _b === void 0 ? void 0 : _b.declared);
-    const localStateValues = ((_c = app.schema.local) === null || _c === void 0 ? void 0 : _c.declared) && Object.values((_d = app.schema.local) === null || _d === void 0 ? void 0 : _d.declared);
-    if ((globalStateValues === null || globalStateValues === void 0 ? void 0 : globalStateValues.length) || (localStateValues === null || localStateValues === void 0 ? void 0 : localStateValues.length)) {
-        yield* (0, writer_1.jsDoc)({
+    const globalStateValues = app.schema.global?.declared && Object.values(app.schema.global?.declared);
+    const localStateValues = app.schema.local?.declared && Object.values(app.schema.local?.declared);
+    if (globalStateValues?.length || localStateValues?.length) {
+        yield* jsDoc({
             description: 'Extracts a binary state value out of an AppState dictionary',
             params: {
                 state: 'The state dictionary containing the state value',
@@ -246,23 +217,23 @@ function* getStateMethods({ app, name }) {
             returns: 'A BinaryState instance containing the state value, or undefined if the key was not found',
         });
         yield `private static getBinaryState(state: AppState, key: string): BinaryState | undefined {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         yield `const value = state[key]`;
         yield `if (!value) return undefined`;
         yield `if (!('valueRaw' in value))`;
-        yield* (0, writer_1.indent)(`throw new Error(\`Failed to parse state value for \${key}; received an int when expected a byte array\`)`);
+        yield* indent(`throw new Error(\`Failed to parse state value for \${key}; received an int when expected a byte array\`)`);
         yield `return {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         yield `asString(): string {`;
-        yield* (0, writer_1.indent)(`return value.value`);
+        yield* indent(`return value.value`);
         yield `},`;
         yield `asByteArray(): Uint8Array {`;
-        yield* (0, writer_1.indent)(`return value.valueRaw`);
+        yield* indent(`return value.valueRaw`);
         yield `}`;
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.NewLine;
-        yield* (0, writer_1.jsDoc)({
+        yield DecIndentAndCloseBlock;
+        yield DecIndentAndCloseBlock;
+        yield NewLine;
+        yield* jsDoc({
             description: 'Extracts a integer state value out of an AppState dictionary',
             params: {
                 state: 'The state dictionary containing the state value',
@@ -271,69 +242,70 @@ function* getStateMethods({ app, name }) {
             returns: 'An IntegerState instance containing the state value, or undefined if the key was not found',
         });
         yield `private static getIntegerState(state: AppState, key: string): IntegerState | undefined {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         yield `const value = state[key]`;
         yield `if (!value) return undefined`;
         yield `if ('valueRaw' in value)`;
-        yield* (0, writer_1.indent)(`throw new Error(\`Failed to parse state value for \${key}; received a byte array when expected a number\`)`);
+        yield* indent(`throw new Error(\`Failed to parse state value for \${key}; received a byte array when expected a number\`)`);
         yield `return {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         yield `asBigInt() {`;
-        yield* (0, writer_1.indent)(`return typeof value.value === 'bigint' ? value.value : BigInt(value.value)`);
+        yield* indent(`return typeof value.value === 'bigint' ? value.value : BigInt(value.value)`);
         yield `},`;
         yield `asNumber(): number {`;
-        yield* (0, writer_1.indent)(`return typeof value.value === 'bigint' ? Number(value.value) : value.value`);
+        yield* indent(`return typeof value.value === 'bigint' ? Number(value.value) : value.value`);
         yield `},`;
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.NewLine;
+        yield DecIndentAndCloseBlock;
+        yield DecIndentAndCloseBlock;
+        yield NewLine;
     }
-    if (globalStateValues === null || globalStateValues === void 0 ? void 0 : globalStateValues.length) {
-        yield* (0, writer_1.jsDoc)(`Returns the smart contract's global state wrapped in a strongly typed accessor with options to format the stored value`);
+    if (globalStateValues?.length) {
+        yield* jsDoc(`Returns the smart contract's global state wrapped in a strongly typed accessor with options to format the stored value`);
         yield `public async getGlobalState(): Promise<${name}['state']['global']> {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         yield `const state = await this.appClient.getGlobalState()`;
         yield `return {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         for (const stateValue of globalStateValues) {
             yield `get ${stateValue.key}() {`;
             if (stateValue.type === 'uint64') {
-                yield* (0, writer_1.indent)(`return ${name}Client.getIntegerState(state, '${stateValue.key}')`);
+                yield* indent(`return ${name}Client.getIntegerState(state, '${stateValue.key}')`);
             }
             else {
-                yield* (0, writer_1.indent)(`return ${name}Client.getBinaryState(state, '${stateValue.key}')`);
+                yield* indent(`return ${name}Client.getBinaryState(state, '${stateValue.key}')`);
             }
             yield '},';
         }
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.NewLine;
+        yield DecIndentAndCloseBlock;
+        yield DecIndentAndCloseBlock;
+        yield NewLine;
     }
-    if (localStateValues === null || localStateValues === void 0 ? void 0 : localStateValues.length) {
-        yield* (0, writer_1.jsDoc)({
+    if (localStateValues?.length) {
+        yield* jsDoc({
             description: `Returns the smart contract's local state wrapped in a strongly typed accessor with options to format the stored value`,
             params: {
                 account: `The address of the account for which to read local state from`,
             },
         });
         yield `public async getLocalState(account: string | SendTransactionFrom): Promise<${name}['state']['local']> {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         yield `const state = await this.appClient.getLocalState(account)`;
         yield `return {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         for (const stateValue of localStateValues) {
             yield `get ${stateValue.key}() {`;
             if (stateValue.type === 'uint64') {
-                yield* (0, writer_1.indent)(`return ${name}Client.getIntegerState(state, '${stateValue.key}')`);
+                yield* indent(`return ${name}Client.getIntegerState(state, '${stateValue.key}')`);
             }
             else {
-                yield* (0, writer_1.indent)(`return ${name}Client.getBinaryState(state, '${stateValue.key}')`);
+                yield* indent(`return ${name}Client.getBinaryState(state, '${stateValue.key}')`);
             }
             yield '},';
         }
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.NewLine;
+        yield DecIndentAndCloseBlock;
+        yield DecIndentAndCloseBlock;
+        yield NewLine;
     }
 }
-//# sourceMappingURL=call-client.js.map
+
+export { callClient };

package/client/call-composer-types.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+var writer = require('../output/writer.cjs');
+var algokit = require('@algorandfoundation/algokit-utils');
+var sanitization = require('../util/sanitization.cjs');
+var getCallConfigSummary = require('./helpers/get-call-config-summary.cjs');
+var deployTypes = require('./deploy-types.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var algokit__namespace = /*#__PURE__*/_interopNamespaceDefault(algokit);
+
+function* callComposerType(ctx) {
+    const { name, callConfig, app } = ctx;
+    yield `export type ${name}Composer<TReturns extends [...any[]] = []> = {`;
+    yield writer.IncIndent;
+    yield* callComposerTypeNoops(ctx);
+    yield* callComposerOperationMethodType(ctx, `Updates an existing instance of the ${app.contract.name} smart contract`, callConfig.updateMethods, 'update', true);
+    yield* callComposerOperationMethodType(ctx, `Deletes an existing instance of the ${app.contract.name} smart contract`, callConfig.deleteMethods, 'delete');
+    yield* callComposerOperationMethodType(ctx, `Opts the user into an existing instance of the ${app.contract.name} smart contract`, callConfig.optInMethods, 'optIn');
+    yield* callComposerOperationMethodType(ctx, `Makes a close out call to an existing instance of the ${app.contract.name} smart contract`, callConfig.closeOutMethods, 'closeOut');
+    yield* callComposerTypeClearState(ctx);
+    yield* writer.jsDoc({
+        description: 'Adds a transaction to the composer',
+        params: {
+            txn: 'One of: A TransactionWithSigner object (returned as is), a TransactionToSign object (signer is obtained from the signer property), a Transaction object (signer is extracted from the defaultSender parameter), an async SendTransactionResult returned by one of algokit utils helpers (signer is obtained from the defaultSender parameter)',
+            defaultSender: 'The default sender to be used to obtain a signer where the object provided to the transaction parameter does not' +
+                ' include a signer.',
+        },
+    });
+    yield `addTransaction(txn: TransactionWithSigner | TransactionToSign | Transaction | Promise<SendTransactionResult>, defaultSender?: SendTransactionFrom): ${name}Composer<TReturns>`;
+    yield* writer.jsDoc({
+        description: 'Returns the underlying AtomicTransactionComposer instance',
+    });
+    yield `atc(): Promise<AtomicTransactionComposer>`;
+    yield* writer.jsDoc({
+        description: 'Simulates the transaction group and returns the result',
+    });
+    yield `simulate(options?: SimulateOptions): Promise<${name}ComposerSimulateResult<TReturns>>`;
+    yield* writer.jsDoc({
+        description: 'Executes the transaction group and returns the results',
+    });
+    yield `execute(sendParams?: AppClientComposeExecuteParams): Promise<${name}ComposerResults<TReturns>>`;
+    yield writer.DecIndentAndCloseBlock;
+    yield `export type SimulateOptions = Omit<ConstructorParameters<typeof modelsv2.SimulateRequest>[0], 'txnGroups'>`;
+    yield `export type ${name}ComposerSimulateResult<TReturns extends [...any[]]> = {`;
+    yield writer.IncIndent;
+    yield `returns: TReturns`;
+    yield `methodResults: ABIResult[]`;
+    yield `simulateResponse: modelsv2.SimulateResponse`;
+    yield writer.DecIndentAndCloseBlock;
+    yield `export type ${name}ComposerResults<TReturns extends [...any[]]> = {`;
+    yield writer.IncIndent;
+    yield `returns: TReturns`;
+    yield `groupId: string`;
+    yield `txIds: string[]`;
+    yield `transactions: Transaction[]`;
+    yield writer.DecIndentAndCloseBlock;
+}
+function* callComposerTypeClearState({ app, name }) {
+    yield* writer.jsDoc({
+        description: `Makes a clear_state call to an existing instance of the ${app.contract.name} smart contract.`,
+        params: {
+            args: `The arguments for the bare call`,
+        },
+        returns: `The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions`,
+    });
+    yield `clearState(args?: BareCallArgs & AppClientComposeCallCoreParams & CoreAppCallArgs): ${name}Composer<[...TReturns, undefined]>`;
+    yield writer.NewLine;
+}
+function* callComposerTypeNoops({ app, name, callConfig, methodSignatureToUniqueName }) {
+    for (const method of app.contract.methods) {
+        const methodSignature = algokit__namespace.getABIMethodSignature(method);
+        const methodName = sanitization.makeSafeMethodIdentifier(methodSignatureToUniqueName[methodSignature]);
+        // Skip methods which don't support a no_op call config
+        if (!callConfig.callMethods.includes(methodSignature))
+            continue;
+        yield* writer.jsDoc({
+            description: `Calls the ${algokit__namespace.getABIMethodSignature(method)} ABI method.`,
+            abiDescription: method.desc,
+            params: {
+                args: `The arguments for the contract call`,
+                params: `Any additional parameters for the call`,
+            },
+            returns: `The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions`,
+        });
+        yield `${methodName}(args: MethodArgs<'${methodSignature}'>, params?: AppClientComposeCallCoreParams & CoreAppCallArgs): ${name}Composer<[...TReturns, MethodReturn<'${methodSignature}'>]>`;
+        yield writer.NewLine;
+    }
+}
+function* callComposerOperationMethodType({ app, methodSignatureToUniqueName, name }, description, methods, verb, includeCompilation) {
+    if (methods.length) {
+        yield* writer.jsDoc(`Gets available ${verb} methods`);
+        yield `readonly ${verb}: {`;
+        yield writer.IncIndent;
+        for (const methodSig of methods) {
+            const onComplete = verb === 'create' ? deployTypes.getCreateOnCompleteOptions(methodSig, app) : undefined;
+            if (methodSig === getCallConfigSummary.BARE_CALL) {
+                yield* writer.jsDoc({
+                    description: `${description} using a bare call.`,
+                    params: {
+                        args: `The arguments for the bare call`,
+                    },
+                    returns: `The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions`,
+                });
+                yield `bare(args${onComplete?.isOptional !== false ? '?' : ''}: BareCallArgs & AppClientComposeCallCoreParams ${includeCompilation ? '& AppClientCompilationParams ' : ''}& CoreAppCallArgs${onComplete?.type ? ` & ${onComplete.type}` : ''}): ${name}Composer<[...TReturns, undefined]>`;
+            }
+            else {
+                const uniqueName = methodSignatureToUniqueName[methodSig];
+                yield* writer.jsDoc({
+                    description: `${description} using the ${methodSig} ABI method.`,
+                    params: {
+                        args: `The arguments for the smart contract call`,
+                        params: `Any additional parameters for the call`,
+                    },
+                    returns: `The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions`,
+                });
+                yield `${sanitization.makeSafeMethodIdentifier(uniqueName)}(args: MethodArgs<'${methodSig}'>, params${onComplete?.isOptional !== false ? '?' : ''}: AppClientComposeCallCoreParams${includeCompilation ? ' & AppClientCompilationParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}): ${name}Composer<[...TReturns, MethodReturn<'${methodSig}'>]>`;
+            }
+        }
+        yield writer.DecIndentAndCloseBlock;
+        yield writer.NewLine;
+    }
+}
+
+exports.callComposerType = callComposerType;

package/client/call-composer-types.d.ts

@@ -1,4 +1,3 @@
 import { DocumentParts } from '../output/writer';
 import { GeneratorContext } from './generator-context';
 export declare function callComposerType(ctx: GeneratorContext): DocumentParts;
-//# sourceMappingURL=call-composer-types.d.ts.map