@aeternity/aepp-sdk 13.2.2 → 13.3.1

package/src/apis/compiler/compiler.ts

@@ -35,7 +35,7 @@ import {
   ApiVersionOptionalParams,
   ApiVersionResponse,
   ApiOptionalParams,
-  ApiResponse
+  ApiResponse,
 } from "./models";
 
 export class Compiler extends coreClient.ServiceClient {
@@ -56,7 +56,7 @@ export class Compiler extends coreClient.ServiceClient {
       options = {};
     }
     const defaults: CompilerOptionalParams = {
-      requestContentType: "application/json; charset=utf-8"
+      requestContentType: "application/json; charset=utf-8",
     };
 
     const packageDetails = `azsdk-js-compiler/1.0.0-beta.1`;
@@ -69,9 +69,9 @@ export class Compiler extends coreClient.ServiceClient {
       ...defaults,
       ...options,
       userAgentOptions: {
-        userAgentPrefix
+        userAgentPrefix,
       },
-      endpoint: options.endpoint ?? options.baseUri ?? "{$host}"
+      endpoint: options.endpoint ?? options.baseUri ?? "{$host}",
     };
     super(optionsWithDefaults);
     // Parameter assignments
@@ -85,11 +85,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   generateACI(
     body: Contract,
-    options?: GenerateACIOptionalParams
+    options?: GenerateACIOptionalParams,
   ): Promise<GenerateACIResponse> {
     return this.sendOperationRequest(
       { body, options },
-      generateACIOperationSpec
+      generateACIOperationSpec,
     );
   }
 
@@ -100,11 +100,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   compileContract(
     body: Contract,
-    options?: CompileContractOptionalParams
+    options?: CompileContractOptionalParams,
   ): Promise<CompileContractResponse> {
     return this.sendOperationRequest(
       { body, options },
-      compileContractOperationSpec
+      compileContractOperationSpec,
     );
   }
 
@@ -115,11 +115,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   decodeCallResult(
     body: SophiaCallResultInput,
-    options?: DecodeCallResultOptionalParams
+    options?: DecodeCallResultOptionalParams,
   ): Promise<DecodeCallResultResponse> {
     return this.sendOperationRequest(
       { body, options },
-      decodeCallResultOperationSpec
+      decodeCallResultOperationSpec,
     );
   }
 
@@ -130,11 +130,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   decodeCallResultBytecode(
     body: BytecodeCallResultInput,
-    options?: DecodeCallResultBytecodeOptionalParams
+    options?: DecodeCallResultBytecodeOptionalParams,
   ): Promise<DecodeCallResultBytecodeResponse> {
     return this.sendOperationRequest(
       { body, options },
-      decodeCallResultBytecodeOperationSpec
+      decodeCallResultBytecodeOperationSpec,
     );
   }
 
@@ -145,11 +145,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   encodeCalldata(
     body: FunctionCallInput,
-    options?: EncodeCalldataOptionalParams
+    options?: EncodeCalldataOptionalParams,
   ): Promise<EncodeCalldataResponse> {
     return this.sendOperationRequest(
       { body, options },
-      encodeCalldataOperationSpec
+      encodeCalldataOperationSpec,
     );
   }
 
@@ -160,11 +160,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   decodeCalldataBytecode(
     body: DecodeCalldataBytecode,
-    options?: DecodeCalldataBytecodeOptionalParams
+    options?: DecodeCalldataBytecodeOptionalParams,
   ): Promise<DecodeCalldataBytecodeResponse> {
     return this.sendOperationRequest(
       { body, options },
-      decodeCalldataBytecodeOperationSpec
+      decodeCalldataBytecodeOperationSpec,
     );
   }
 
@@ -175,11 +175,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   decodeCalldataSource(
     body: DecodeCalldataSource,
-    options?: DecodeCalldataSourceOptionalParams
+    options?: DecodeCalldataSourceOptionalParams,
   ): Promise<DecodeCalldataSourceResponse> {
     return this.sendOperationRequest(
       { body, options },
-      decodeCalldataSourceOperationSpec
+      decodeCalldataSourceOperationSpec,
     );
   }
 
@@ -190,11 +190,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   getFateAssemblerCode(
     body: ByteCodeInput,
-    options?: GetFateAssemblerCodeOptionalParams
+    options?: GetFateAssemblerCodeOptionalParams,
   ): Promise<GetFateAssemblerCodeResponse> {
     return this.sendOperationRequest(
       { body, options },
-      getFateAssemblerCodeOperationSpec
+      getFateAssemblerCodeOperationSpec,
     );
   }
 
@@ -205,11 +205,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   validateByteCode(
     body: ValidateByteCodeInput,
-    options?: ValidateByteCodeOptionalParams
+    options?: ValidateByteCodeOptionalParams,
   ): Promise<void> {
     return this.sendOperationRequest(
       { body, options },
-      validateByteCodeOperationSpec
+      validateByteCodeOperationSpec,
     );
   }
 
@@ -220,11 +220,11 @@ export class Compiler extends coreClient.ServiceClient {
    */
   getCompilerVersion(
     body: ByteCodeInput,
-    options?: GetCompilerVersionOptionalParams
+    options?: GetCompilerVersionOptionalParams,
   ): Promise<GetCompilerVersionResponse> {
     return this.sendOperationRequest(
       { body, options },
-      getCompilerVersionOperationSpec
+      getCompilerVersionOperationSpec,
     );
   }
 
@@ -264,177 +264,177 @@ const generateACIOperationSpec: coreClient.OperationSpec = {
         type: {
           name: "Sequence",
           element: {
-            type: { name: "Dictionary", value: { type: { name: "any" } } }
-          }
-        }
-      }
+            type: { name: "Dictionary", value: { type: { name: "any" } } },
+          },
+        },
+      },
     },
     400: {
       bodyMapper: {
         type: {
           name: "Sequence",
-          element: { type: { name: "Composite", className: "CompilerError" } }
-        }
+          element: { type: { name: "Composite", className: "CompilerError" } },
+        },
       },
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const compileContractOperationSpec: coreClient.OperationSpec = {
   path: "/compile",
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.CompileResult
+      bodyMapper: Mappers.CompileResult,
     },
     400: {
       bodyMapper: {
         type: {
           name: "Sequence",
-          element: { type: { name: "Composite", className: "CompilerError" } }
-        }
+          element: { type: { name: "Composite", className: "CompilerError" } },
+        },
       },
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const decodeCallResultOperationSpec: coreClient.OperationSpec = {
   path: "/decode-call-result",
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: { type: { name: "any" } }
+      bodyMapper: { type: { name: "any" } },
     },
     400: {
       bodyMapper: {
         type: {
           name: "Sequence",
-          element: { type: { name: "Composite", className: "CompilerError" } }
-        }
+          element: { type: { name: "Composite", className: "CompilerError" } },
+        },
       },
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body1,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const decodeCallResultBytecodeOperationSpec: coreClient.OperationSpec = {
   path: "/decode-call-result/bytecode",
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.DecodedCallresult
+      bodyMapper: Mappers.DecodedCallresult,
     },
     400: {
       bodyMapper: {
         type: {
           name: "Sequence",
-          element: { type: { name: "Composite", className: "CompilerError" } }
-        }
+          element: { type: { name: "Composite", className: "CompilerError" } },
+        },
       },
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body2,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const encodeCalldataOperationSpec: coreClient.OperationSpec = {
   path: "/encode-calldata",
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.Calldata
+      bodyMapper: Mappers.Calldata,
     },
     400: {
       bodyMapper: {
         type: {
           name: "Sequence",
-          element: { type: { name: "Composite", className: "CompilerError" } }
-        }
+          element: { type: { name: "Composite", className: "CompilerError" } },
+        },
       },
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body3,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const decodeCalldataBytecodeOperationSpec: coreClient.OperationSpec = {
   path: "/decode-calldata/bytecode",
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.DecodedCalldata
+      bodyMapper: Mappers.DecodedCalldata,
     },
     400: {
       bodyMapper: Mappers.ErrorModel,
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body4,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const decodeCalldataSourceOperationSpec: coreClient.OperationSpec = {
   path: "/decode-calldata/source",
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.DecodedCalldata
+      bodyMapper: Mappers.DecodedCalldata,
     },
     400: {
       bodyMapper: {
         type: {
           name: "Sequence",
-          element: { type: { name: "Composite", className: "CompilerError" } }
-        }
+          element: { type: { name: "Composite", className: "CompilerError" } },
+        },
       },
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body5,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const getFateAssemblerCodeOperationSpec: coreClient.OperationSpec = {
   path: "/fate-assembler",
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.FateAssembler
+      bodyMapper: Mappers.FateAssembler,
     },
     400: {
       bodyMapper: Mappers.ErrorModel,
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body6,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const validateByteCodeOperationSpec: coreClient.OperationSpec = {
   path: "/validate-byte-code",
@@ -445,67 +445,67 @@ const validateByteCodeOperationSpec: coreClient.OperationSpec = {
       bodyMapper: {
         type: {
           name: "Sequence",
-          element: { type: { name: "Composite", className: "CompilerError" } }
-        }
+          element: { type: { name: "Composite", className: "CompilerError" } },
+        },
       },
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body7,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const getCompilerVersionOperationSpec: coreClient.OperationSpec = {
   path: "/compiler-version",
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.CompilerVersion
+      bodyMapper: Mappers.CompilerVersion,
     },
     400: {
       bodyMapper: Mappers.ErrorModel,
-      isError: true
-    }
+      isError: true,
+    },
   },
   requestBody: Parameters.body6,
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
-  serializer
+  serializer,
 };
 const versionOperationSpec: coreClient.OperationSpec = {
   path: "/version",
   httpMethod: "GET",
   responses: {
     200: {
-      bodyMapper: Mappers.CompilerVersion
+      bodyMapper: Mappers.CompilerVersion,
     },
     500: {
       bodyMapper: Mappers.ErrorModel,
-      isError: true
-    }
+      isError: true,
+    },
   },
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.accept],
-  serializer
+  serializer,
 };
 const apiVersionOperationSpec: coreClient.OperationSpec = {
   path: "/api-version",
   httpMethod: "GET",
   responses: {
     200: {
-      bodyMapper: Mappers.ApiVersion
+      bodyMapper: Mappers.ApiVersion,
     },
     500: {
       bodyMapper: Mappers.ErrorModel,
-      isError: true
-    }
+      isError: true,
+    },
   },
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.accept],
-  serializer
+  serializer,
 };
 const apiOperationSpec: coreClient.OperationSpec = {
   path: "/api",
@@ -513,15 +513,15 @@ const apiOperationSpec: coreClient.OperationSpec = {
   responses: {
     200: {
       bodyMapper: {
-        type: { name: "Dictionary", value: { type: { name: "any" } } }
-      }
+        type: { name: "Dictionary", value: { type: { name: "any" } } },
+      },
     },
     400: {
       bodyMapper: Mappers.ErrorModel,
-      isError: true
-    }
+      isError: true,
+    },
   },
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.accept],
-  serializer
+  serializer,
 };

package/src/apis/compiler/models/index.ts

@@ -29,6 +29,7 @@ export interface CompileResult {
   /** Prefixed (cb_) Base64Check encoded byte array */
   bytecode: string;
   aci: Record<string, unknown>[];
+  warnings: CompilerError[];
 }
 
 export interface SophiaCallResultInput {