@hitc/netsuite-types 2026.1.5 → 2026.1.6

package/N/format/i18n.d.ts

@@ -45,9 +45,9 @@ export function getCurrencyFormatter(options: GetCurrencyFormatterOptions): Curr
 /** Create format.NumberFormatter object to format numbers into strings. Costs 10 governance units. */
 export function getNumberFormatter(options?: GetNumberFormatterOptions): NumberFormatter;
 
-export function getPhoneNumberFormatter(options: { defaultCountry: Country }): PhoneNumberFormatter; // TODO: This isn't documented, but shows up in release preview
+export function getPhoneNumberFormatter(options: { formatType: PhoneNumberFormatType }): PhoneNumberFormatter;
 
-export function getPhoneNumberParser(options: { defaultCountry: Country }): PhoneNumberParser; // TODO: Test this; it's not documented but shows up in the example
+export function getPhoneNumberParser(options: { defaultCountry: Country }): PhoneNumberParser;
 
 interface GetCurrencyFormatterOptions {
   /** Code of the currency that is used by formatter. */

package/N/llm.d.ts

@@ -31,19 +31,140 @@ interface Citation {
 
 /** The response returned from LLM. Use the llm.generateText(options) or the llm.generateText.promise(options) method to retrieve a response from the LLM. */
 interface Response {
+    /** List of chat messages. */
+    readonly chatHistory: ChatMessage[];
+    /** List of citations used to generate the response. */
     readonly citations: Citation[];
+    /** List of documents used to generate the response. */
     readonly documents: Document[];
-    readonly text: string;
+    /** Model used to produce the LLM response. */
     readonly model: string;
-    readonly chatHistory: ChatMessage[];
+    /** Text returned by the LLM. */
+    readonly text: string;
+    /** Tool calls requested by the LLM. @since 2025.2 */
+    readonly toolCalls: ToolCall[];
+    /** Token usage for a request to the LLM. @since 2025.2 */
+    readonly usage: Usage;
 }
 
+/**
+ * The streamed response returned from the LLM.
+ * Use llm.generateTextStreamed(options) or llm.evaluatePromptStreamed(options) (or their promise versions) to retrieve a streamed response.
+ *
+ * You can access the partial response (using the StreamedResponse.text property) before the entire response has been generated, as well as StreamedResponse.model.
+ * Other properties (such as StreamedResponse.documents and StreamedResponse.citations) are accessible only after the entire response has been generated.
+ */
 interface StreamedResponse {
+    /** List of chat messages. */
+    readonly chatHistory: ChatMessage[];
+    /** List of citations used to generate the streamed response. */
     readonly citations: Citation[];
+    /** List of documents used to generate the streamed response. */
     readonly documents: Document[];
-    readonly text: string;
+    /** Model used to produce the streamed response. */
     readonly model: string;
-    readonly chatHistory: ChatMessage[];
+    /** Text returned by the LLM. While streaming, this contains the partial response received so far. */
+    readonly text: string;
+    /** Tool calls requested by the LLM. @since 2025.2 */
+    readonly toolCalls: ToolCall[];
+    /**
+     * Returns an iterator that lets you examine each token returned by the LLM as it is generated.
+     *
+     * @example
+     *  const response = llm.generateTextStreamed({ prompt: 'Hello World' });
+     *  const iter = response.iterator();
+     *  iter.each((token) => {
+     *      log.debug('token.value: ' + token.value);
+     *      log.debug('response.text: ' + response.text); // Partial response up to and including this token
+     *      return true;
+     *  });
+     */
+    iterator(): StreamedResponseIterator;
+}
+
+interface StreamedResponseIterator {
+    /** Iterates over each token returned by the LLM. Return true from the callback to continue iterating, or false to stop. */
+    each(callback: (token: { value: string }) => boolean): void;
+}
+
+/**
+ * A tool the LLM can request. Created using llm.createTool(options).
+ *
+ * Tools are callable operations that the LLM can request to augment its responses.
+ * They are custom utilities that you define, and they let the LLM retrieve external data (such as data from NetSuite using SuiteQL),
+ * perform calculations, or trigger business logic as part of an LLM interaction.
+ *
+ * Provide tools to llm.generateText(options) or llm.generateTextStreamed(options) using the options.tools parameter.
+ * @since 2025.2
+ */
+interface Tool {
+    /** The description of the tool. Helps the LLM understand when to request the tool. */
+    readonly description: string;
+    /** The name of the tool. Used when the LLM refers to this tool in tool call requests. */
+    readonly name: string;
+    /** The parameters of the tool. */
+    readonly parameters: ToolParameter[];
+}
+
+/**
+ * A tool call request from the LLM, returned as part of the response from llm.generateText(options) or llm.generateTextStreamed(options)
+ * through the Response.toolCalls or StreamedResponse.toolCalls property.
+ *
+ * The LLM generates a tool call request when it determines that running a particular tool may help provide a more accurate or useful response to your prompt.
+ * Your SuiteScript code is responsible for iterating over these tool calls, running the appropriate handler logic with the provided parameters,
+ * and returning the results to the LLM (as llm.ToolResult objects created using llm.createToolResult(options)).
+ * @since 2025.2
+ */
+interface ToolCall {
+    /** The name of the requested tool. */
+    readonly name: string;
+    /**
+     * The parameters of the requested tool as key-value pairs for each input parameter required by the tool, as specified in the tool definition.
+     *
+     * Note: The N/llm Module Members table lists this property's type as llm.ToolParameter[], but the llm.ToolCall object description and the
+     * examples in "Tooling in the N/llm Module" show a plain object of key-value pairs (e.g. TOOL_HANDLERS[call.name](call.parameters) where
+     * the handler reads options.userName).
+     */
+    readonly parameters: { [name: string]: any };
+}
+
+/**
+ * A parameter for a tool. Created using llm.createToolParameter(options).
+ *
+ * Tool parameters define the individual input values that the LLM must provide when requesting a tool call.
+ * @since 2025.2
+ */
+interface ToolParameter {
+    /** The description of the tool parameter. Helps the LLM prompt for and fill in the value correctly. */
+    readonly description: string;
+    /** The name of the tool parameter. Used when the LLM refers to this specific input in tool call requests. */
+    readonly name: string;
+    /** The type of the tool parameter. Values are from the llm.ToolParameterType enum. */
+    readonly type: string;
+}
+
+/**
+ * A tool result to send back to the LLM. Created using llm.createToolResult(options).
+ *
+ * Tool results let you send the output of a tool (such as the result of a SuiteQL query or a business operation) back to the LLM
+ * by providing them to subsequent llm.generateText(options) or llm.generateTextStreamed(options) calls using the options.toolResults parameter.
+ * @since 2025.2
+ */
+interface ToolResult {
+    /** The originating tool call request from the LLM. */
+    readonly call: ToolCall;
+    /** The outputs from running the tool specified in the tool call request. */
+    readonly outputs: object[];
+}
+
+/** Token usage for a request to the LLM. Returned through the Response.usage property. @since 2025.2 */
+interface Usage {
+    /** The number of tokens in the response from the LLM. */
+    readonly completionTokens: number;
+    /** The number of tokens in the request to the LLM. */
+    readonly promptTokens: number;
+    /** The total number of tokens for the entire request to the LLM. */
+    readonly totalTokens: number;
 }
 
 /**
@@ -65,7 +186,64 @@ export function createChatMessage(options: { role: string, text: string }): Chat
  */
 export function createDocument(options: { data: string, id: string }): Document;
 
-export const embed: IEmbededFunction
+/**
+ * Creates a tool definition that you can provide when calling llm.generateText(options) or llm.generateTextStreamed(options) using the options.tools parameter.
+ *
+ * Tools are callable operations that the LLM can request to augment its responses. They are custom utilities that you define, and they let the LLM
+ * retrieve external data (such as data from NetSuite using SuiteQL), perform calculations, or trigger business logic as part of an LLM interaction.
+ * You can create and provide multiple tool definitions based on your use cases.
+ * @governance none
+ * @since 2025.2
+ */
+export function createTool(options: {
+    /** A description of what the tool does. This parameter helps the LLM understand when to request the tool. */
+    description: string,
+    /** A unique identifier for the tool. Used when the LLM refers to this tool in tool call requests (which are represented as llm.ToolCall objects). */
+    name: string,
+    /** An array of tool parameters, which are created using llm.createToolParameter(options). These parameters specify the input values required to run the tool. */
+    parameters: ToolParameter[],
+}): Tool;
+
+/**
+ * Creates a tool parameter that you can provide when creating a tool using llm.createTool(options).
+ *
+ * Tool parameters define the individual input values that the LLM must provide when requesting a tool call.
+ * These parameters help the LLM understand how to call the tool accurately and ensure that tool call requests include all necessary and correctly typed data.
+ * @governance none
+ * @since 2025.2
+ */
+export function createToolParameter(options: {
+    /** A description of what data the tool parameter represents. This parameter helps the LLM prompt for and fill in the value correctly. */
+    description: string,
+    /** A unique identifier for the tool parameter. Used when the LLM refers to this specific input in tool call requests. */
+    name: string,
+    /** The data type of the parameter. Use values from the llm.ToolParameterType enum to set this parameter. */
+    type: ToolParameterType | string,
+}): ToolParameter;
+
+/**
+ * Creates a tool result that you can provide when calling llm.generateText(options) or llm.generateTextStreamed(options) using the options.toolResults parameter.
+ *
+ * Tool results let you send the output of a tool (such as the result of a SuiteQL query or a business operation) back to the LLM.
+ * You generate tool results in your SuiteScript code after handling a tool call request, which is represented by a llm.ToolCall object.
+ * @governance none
+ * @since 2025.2
+ */
+export function createToolResult(options: {
+    /** The original tool call request from the LLM. This parameter links the result to a specific tool call request. */
+    call: ToolCall,
+    /** An array of output objects representing the results of running the tool. Each output object typically includes a result property (or another relevant property) that contains the value to send back to the LLM. */
+    outputs: object[],
+}): ToolResult;
+
+/**
+ * Returns the embeddings from the LLM for a given input.
+ *
+ * You can use embeddings to compare the similarity of a set of inputs, which is useful for finding similar items based on item attributes,
+ * implementing semantic search, and applying text classification or text clustering.
+ * @governance 50
+ */
+export const embed: IEmbedFunction;
 
 /**
  * Takes the ID of an existing prompt and values for variables used in the prompt and returns the response from the LLM.
@@ -77,31 +255,55 @@ export const embed: IEmbededFunction
  * When unlimited usage mode is used, this method accepts the OCI configuration parameters.
  * You can also specify OCI configuration parameters on the SuiteScript tab of the AI Preferences page.
  * For more information, see Using Your Own OCI Configuration for SuiteScript Generative AI APIs.
+ * @governance 100
  */
 export const evaluatePrompt: IEvaluatePromptFunction;
 
+/** Alias for llm.evaluatePrompt(options). Uses the same parameters and can throw the same errors. */
+export const executePrompt: IEvaluatePromptFunction;
+
+/**
+ * Takes the ID of an existing prompt and values for variables used in the prompt and returns the streamed response from the LLM.
+ * When you're using unlimited usage mode, this method also accepts the OCI configuration parameters.
+ * @governance 100
+ */
 export const evaluatePromptStreamed: IEvaluatePromptStreamedFunction;
 
+/** Alias for llm.evaluatePromptStreamed(options). Uses the same parameters and can throw the same errors. */
+export const executePromptStreamed: IEvaluatePromptStreamedFunction;
+
+/**
+ * Takes a prompt and parameters for the LLM and returns the response from the LLM.
+ * When you're using unlimited usage mode, this method also accepts the OCI configuration parameters.
+ * @governance 100
+ */
 export const generateText: GenerateTextFunction;
 
+/** Alias for llm.generateText(options). Uses the same parameters and can throw the same errors. */
+export const chat: GenerateTextFunction;
+
 /**
  * Returns the streamed response from the LLM for a given prompt.
  *
  * This method is similar to llm.generateText(options) but returns the LLM response as a stream.
  * After calling this method, you can access the partial response (using the StreamedResponse.text property of the returned llm.StreamedResponse object) before the entire response has been generated.
  * You can also use an iterator to examine each token returned by the LLM.
+ * @governance 100
  */
 export const generateTextStreamed: GenerateTextStreamedFunction;
 
+/** Alias for llm.generateTextStreamed(options). Uses the same parameters and can throw the same errors. */
+export const chatStreamed: GenerateTextStreamedFunction;
+
 /** Returns the number of free requests in the current month. */
 export const getRemainingFreeUsage: GetRemainingFreeUsageFunction;
 
 /** Returns the number of free embeddings requests in the current month. This method tracks free requests for embed API calls, such as llm.embed(options). To track free requests for non-embed API calls (such as llm.generateText(options)), use llm.getRemainingFreeUsage() instead. */
 export const getRemainingFreeEmbedUsage: GetRemainingFreeUsageFunction;
 
-interface IEmbededFunction {
-    (options: IEmbedOptions): EmbeddedResponse;
-    promise(options: IEmbedOptions): Promise<EmbeddedResponse>;
+interface IEmbedFunction {
+    (options: IEmbedOptions): EmbedResponse;
+    promise(options: IEmbedOptions): Promise<EmbedResponse>;
 }
 
 interface IEvaluatePromptFunction {
@@ -115,13 +317,13 @@ interface IEvaluatePromptStreamedFunction {
 }
 
 interface GenerateTextFunction {
-    (options: IGenerateTextOptions): Response;
-    promise(options: IGenerateTextOptions): Promise<Response>;
+    (options: IGenerateTextOptions | IGenerateTextToolResultsOptions): Response;
+    promise(options: IGenerateTextOptions | IGenerateTextToolResultsOptions): Promise<Response>;
 }
 
 interface GenerateTextStreamedFunction {
-    (options: IGenerateTextOptions): StreamedResponse;
-    promise(options: IGenerateTextOptions): Promise<StreamedResponse>;
+    (options: IGenerateTextStreamedOptions | IGenerateTextStreamedToolResultsOptions): StreamedResponse;
+    promise(options: IGenerateTextStreamedOptions | IGenerateTextStreamedToolResultsOptions): Promise<StreamedResponse>;
 }
 
 interface GetRemainingFreeUsageFunction {
@@ -129,7 +331,9 @@ interface GetRemainingFreeUsageFunction {
     promise(): Promise<number>;
 }
 
-interface EmbeddedResponse {
+/** The embeddings response returned from the LLM. */
+interface EmbedResponse {
+    /** The embeddings returned from the LLM. */
     readonly embeddings: number[];
     /** The list of inputs used to generate the embeddings response. */
     readonly inputs: string[];
@@ -138,20 +342,33 @@ interface EmbeddedResponse {
 }
 
 interface IEmbedOptions {
-    /** An array of inputs to get embeddings for. */
+    /** An array of inputs to get embeddings for. You can provide a maximum of 96 inputs in a single call. */
     inputs: string[] | readonly string[];
-    /** The embed model family to use. Use values from llm.EmbedModelFamily to set this value. If not specified, the Cohere Embed Multilingual model is used. */
-    embededModelFamily?: string;
+    /**
+     * The number of dimensions of the returned embeddings array.
+     *
+     * You can use this parameter to limit the number of dimensions in the returned embeddings.
+     * The embed model that's currently supported, Cohere Embed v4.0, returns embeddings with 1536 dimensions.
+     * If you generated embeddings using previously supported models and stored these embeddings for later use,
+     * you should regenerate those embeddings using the currently supported embed model with the additional supported dimensions.
+     *
+     * The supported range of values for this parameter is 1 - 1536. The default value is 1536.
+     * @since 2025.2
+     */
+    dimensions?: number;
+    /** The embed model family to use. Use values from llm.EmbedModelFamily to set this value. If not specified, the Cohere Embed model (cohere.embed-v4.0) is used. */
+    embedModelFamily?: EmbedModelFamily | string;
     /** Configuration needed for unlimited usage through OCI Generative AI Service. Required only when accessing the LLM through an Oracle Cloud Account and the OCI Generative AI Service. SuiteApps installed to target accounts are prevented from using the free usage pool for N/llm and must use the OCI configuration. */
     ociConfig?: IOCIConfig;
     /** The amount of time to wait for a response from the LLM, in milliseconds. If not specified, the default value is 30,000. */
     timeout?: number;
     /** The truncation method to use when embeddings input exceeds 512 tokens. Use values from llm.Truncate to set this value. If not specified, no truncation method is used. */
-    truncate?: string;
+    truncate?: Truncate | string;
 }
 
 interface IEvaluatePromptOptions {
-    id: string|number;
+    /** ID of the prompt to evaluate. */
+    id: string | number;
     /**
      * Configuration needed for unlimited usage through OCI Generative AI Service.
      * Required only when accessing the LLM through an Oracle Cloud Account and the OCI Generative AI Service.
@@ -176,23 +393,17 @@ interface IEvaluatePromptOptions {
     variables?: object;
 }
 
-interface IGenerateTextOptions {
-    /** Prompt for the LLM. */
-    prompt: string;
+interface IGenerateTextBaseOptions {
     /** Chat history to be taken into consideration. */
     chatHistory?: ChatMessage[];
-    /** A list of documents to provide additional context for the LLM to generate the response. */
-    documents?: Document[];
     /**
-     * An image to query. You can send an image (as a file.File object) to the LLM and ask questions about the image and get text outputs, such as:
-     * - Advanced image captions
-     * - Detailed description of an image
-     * - Answers to questions about an image
-     * - Information about charts and graphs in an image
+     * A list of documents to provide additional context for the LLM to generate the response.
+     * This parameter is supported only for Cohere models.
      */
-    image?: File;
-    /** Specifies the LLM to use. Use llm.ModelFamily to set the value. If not specified, the Cohere Command R LLM is used. */
+    documents?: Document[];
+    /** Specifies the LLM to use. Use llm.ModelFamily to set the value. If not specified, the Cohere Command A model (cohere.command-a-03-2025) is used. */
     modelFamily?: ModelFamily;
+    /** Parameters of the model. For more information about the model parameters, refer to Offered Pretrained Foundational Models in Generative AI in the Oracle Cloud Infrastructure Documentation. */
     modelParameters?: IModelParameters;
     /**
      * Configuration needed for unlimited usage through OCI Generative AI Service.
@@ -200,10 +411,78 @@ interface IGenerateTextOptions {
      * SuiteApps installed to target accounts are prevented from using the free usage pool for N/llm and must use the OCI configuration.
      */
     ociConfig?: IOCIConfig;
-    /** Preamble override for the LLM. A preamble is the Initial context or guiding message for an LLM. For more details about using a preamble, refer to About the Chat Models in Generative AI (Chat Model Parameters section) in the Oracle Cloud Infrastructure Documentation. */
+    /** Preamble override for the LLM. A preamble is the initial context or guiding message for an LLM. For more details about using a preamble, refer to Offered Pretrained Foundational Models in Generative AI in the Oracle Cloud Infrastructure Documentation. */
     preamble?: string;
+    /**
+     * Specifies the safety mode to use. Safety mode is available for Cohere models only.
+     * Use values from the llm.SafetyMode enum to set the value of this parameter. If not specified, the llm.SafetyMode.STRICT mode is used by default.
+     * @since 2025.1
+     */
+    safetyMode?: SafetyMode | string;
     /** Timeout in milliseconds, defaults to 30,000. */
     timeout?: number;
+    /**
+     * The tools that are available for the LLM to request. Create tools using llm.createTool(options).
+     * When the LLM determines that running a tool may help its response, tool call requests are returned in the Response.toolCalls (or StreamedResponse.toolCalls) property.
+     * @since 2025.2
+     */
+    tools?: Tool[];
+}
+
+interface IGenerateTextOptions extends IGenerateTextBaseOptions {
+    /** Prompt for the LLM. Required if options.toolResults is not specified. */
+    prompt: string;
+    /**
+     * A JSON schema specifying the format of the response.
+     *
+     * Use this parameter to direct the LLM to return its response in a structured JSON format.
+     * You can provide an object that represents a valid JSON schema, and the response will contain keys and values as defined in your schema that are populated by the generated content.
+     * You can then parse the response (Response.text) as JSON content.
+     *
+     * This parameter is supported for Cohere models only, and cannot be used with the documents, tools, or toolResults parameters (MUTUALLY_EXCLUSIVE_ARGUMENTS).
+     * @since 2025.1
+     */
+    responseFormat?: object;
+    /**
+     * @deprecated As of 2025.1 this parameter is no longer included in the Help documentation for llm.generateText(options),
+     * and the Meta Llama (vision-capable) model family is no longer listed in llm.ModelFamily.
+     */
+    image?: File;
+}
+
+/**
+ * Options for a follow-up llm.generateText(options) call that provides tool results back to the LLM.
+ * When toolResults is specified, any prompt provided is ignored — the LLM uses only the specified tool results (and chat history, if available) to generate a follow-up response.
+ * @since 2025.2
+ */
+interface IGenerateTextToolResultsOptions extends IGenerateTextBaseOptions {
+    /** Prompt for the LLM. Ignored when options.toolResults is specified. */
+    prompt?: string;
+    /**
+     * The tool results to use to generate a follow-up response. Create tool results using llm.createToolResult(options).
+     * When you specify a value for this parameter, any prompt you provide using the options.prompt parameter is ignored.
+     */
+    toolResults: ToolResult[];
+}
+
+interface IGenerateTextStreamedOptions extends IGenerateTextBaseOptions {
+    /** Prompt for the LLM. Required if options.toolResults is not specified. */
+    prompt: string;
+}
+
+/**
+ * Options for a follow-up llm.generateTextStreamed(options) call that provides tool results back to the LLM.
+ * When toolResults is specified, any prompt provided is ignored — the LLM uses only the specified tool results (and chat history, if available) to generate a follow-up response.
+ * @since 2025.2
+ */
+interface IGenerateTextStreamedToolResultsOptions extends IGenerateTextBaseOptions {
+    /** Prompt for the LLM. Ignored when options.toolResults is specified. */
+    prompt?: string;
+    /**
+     * The tool results to use to generate a follow-up response. Create tool results using llm.createToolResult(options).
+     * When you specify a value for this parameter, any prompt you provide using the options.prompt parameter is ignored.
+     */
+    toolResults: ToolResult[];
 }
 
 interface Document {
@@ -269,22 +548,50 @@ declare enum ChatRole {
     CHATBOT = "CHATBOT"
 }
 
-/** The large language model to be used to generate embeddings. */
+/** The large language model to be used to generate embeddings. Use this enum to set the value of the options.embedModelFamily parameter in llm.embed(options). */
 declare enum EmbedModelFamily {
-    COHERE_EMBED_ENGLISH = 'cohere.embed-english-v3.0',
-    /** Light versions of embedding models might generate embeddings faster than regular embedding models, but the output might not be as accurate. */
-    COHERE_EMBED_ENGLISH_LIGHT = 'cohere.embed-english-light-v3.0',
-    COHERE_EMBED_MULTILINGUAL = 'cohere.embed-multilingual-v3.0',
-    /** Light versions of embedding models might generate embeddings faster than regular embedding models, but the output might not be as accurate. */
-    COHERE_EMBED_MULTILINGUAL_LIGHT = 'cohere.embed-multilingual-light-v3.0'
+    /** Cohere Embed v4.0. This is the default when the options.embedModelFamily parameter is omitted. */
+    COHERE_EMBED = 'cohere.embed-v4.0',
+    /** Always uses the latest supported Cohere Embed model. */
+    COHERE_EMBED_LATEST = 'cohere.embed-v4.0'
 }
 
-/** The large language model to be used. */
+/** The large language model to be used. Use this enum to set the value of the options.modelFamily parameter in llm.generateText(options) and llm.generateTextStreamed(options). */
 declare enum ModelFamily {
-    /** Always uses the latest supported Cohere model. Cohere Command-R is the default when the options.modelFamily parameter is omitted. */
-    COHERE_COMMAND = 'cohere.command-r-16k',
-    /** Always uses the latest supported Meta Llama model. */
-    META_LLAMA = 'meta.llama-3.1-70b-instruct'
+    /** Cohere Command A. Supports RAG (documents) and preambles. This is the default when the options.modelFamily parameter is omitted. */
+    COHERE_COMMAND = 'cohere.command-a-03-2025',
+    /** Always uses the latest supported Cohere Command model. Supports RAG (documents) and preambles. */
+    COHERE_COMMAND_LATEST = 'cohere.command-a-03-2025',
+    /** OpenAI gpt-oss 120B. Supports preambles; does not support RAG (documents). */
+    GPT_OSS = 'openai.gpt-oss-120b',
+    /** Always uses the latest supported OpenAI gpt-oss model. Supports preambles; does not support RAG (documents). */
+    GPT_OSS_LATEST = 'openai.gpt-oss-120b'
+}
+
+/**
+ * The safety mode to be used for LLM requests.
+ *
+ * Safety mode is available for Cohere models only and is designed to help filter and moderate content generated by the LLM.
+ * When using strict mode or contextual mode, the LLM may refuse to provide certain responses that include sensitive, harmful, or illegal suggestions.
+ *
+ * Use this enum to set the value of the options.safetyMode parameter in llm.generateText(options) and llm.generateTextStreamed(options).
+ * @since 2025.1
+ */
+declare enum SafetyMode {
+    /** This mode offers a less restrictive approach than strict mode but still rejects harmful or illegal suggestions. This mode is suited for creative, entertainment, or academic purposes. */
+    CONTEXTUAL = 'CONTEXTUAL',
+    /** This mode aims to avoid sensitive topics entirely and is suited for corporate communications and customer service. This is the default mode when calling llm.generateText(options) or llm.generateTextStreamed(options). */
+    STRICT = 'STRICT'
+}
+
+/** The data type for a tool parameter. Use this enum to set the value of the options.type parameter in llm.createToolParameter(options). @since 2025.2 */
+declare enum ToolParameterType {
+    ARRAY = 'ARRAY',
+    BOOLEAN = 'BOOLEAN',
+    FLOAT = 'FLOAT',
+    INTEGER = 'INTEGER',
+    OBJECT = 'OBJECT',
+    STRING = 'STRING'
 }
 
 /** The truncation method to use when embeddings input exceeds 512 tokens. Use this enum to set the value of the options.truncate parameter in llm.embed(options). */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hitc/netsuite-types",
-	"version": "2026.1.5",
+	"version": "2026.1.6",
 	"description": "TypeScript typings for SuiteScript 2.0",
 	"keywords": [
 		"netsuite",