n8n-nodes-base 2.32.4 → 2.34.0

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v45.schema.js

@@ -0,0 +1,56 @@
+/**
+ * HTTP Request Node - Version 4.5 - Zod Validation Schemas
+ *
+ * These schemas validate node configuration at runtime.
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, resolveSchema, resolveOneOfSchemas }) {
+
+  // Parameters schema
+  const parametersSchema = z.object({
+    method: z.union([z.literal('DELETE'), z.literal('GET'), z.literal('HEAD'), z.literal('OPTIONS'), z.literal('PATCH'), z.literal('POST'), z.literal('PUT'), expressionSchema]).optional(),
+    url: stringOrExpression,
+    authentication: z.union([z.literal('none'), z.literal('predefinedCredentialType'), z.literal('genericCredentialType')]).optional(),
+    nodeCredentialType: resolveSchema({ parameters, schema: z.string(), required: false, displayOptions: {"show":{"authentication":["predefinedCredentialType"]}}, defaults: {"authentication":"none"} }),
+    genericAuthType: resolveSchema({ parameters, schema: z.union([z.literal('httpBasicAuth'), z.literal('httpBearerAuth'), z.literal('httpDigestAuth'), z.literal('httpHeaderAuth'), z.literal('httpQueryAuth'), z.literal('httpCustomAuth'), z.literal('oAuth1Api'), z.literal('oAuth2Api'), expressionSchema]), required: false, displayOptions: {"show":{"authentication":["genericCredentialType"]}}, defaults: {"authentication":"none"} }),
+    provideSslCertificates: booleanOrExpression.optional(),
+    sendQuery: z.boolean().optional(),
+    specifyQuery: resolveSchema({ parameters, schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendQuery":[true]}}, defaults: {"sendQuery":false} }),
+    queryParameters: resolveSchema({ parameters, schema: z.object({ parameters: z.array(z.object({ name: stringOrExpression.optional(), value: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"sendQuery":[true],"specifyQuery":["keypair"]}}, defaults: {"sendQuery":false,"specifyQuery":"keypair"} }),
+    jsonQuery: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"sendQuery":[true],"specifyQuery":["json"]}}, defaults: {"sendQuery":false,"specifyQuery":"keypair"} }),
+    sendHeaders: z.boolean().optional(),
+    specifyHeaders: resolveSchema({ parameters, schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendHeaders":[true]}}, defaults: {"sendHeaders":false} }),
+    headerParameters: resolveSchema({ parameters, schema: z.object({ parameters: z.array(z.object({ name: stringOrExpression.optional(), value: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"sendHeaders":[true],"specifyHeaders":["keypair"]}}, defaults: {"sendHeaders":false,"specifyHeaders":"keypair"} }),
+    jsonHeaders: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"sendHeaders":[true],"specifyHeaders":["json"]}}, defaults: {"sendHeaders":false,"specifyHeaders":"keypair"} }),
+    sendBody: z.boolean().optional(),
+    contentType: resolveSchema({ parameters, schema: z.union([z.literal('form-urlencoded'), z.literal('multipart-form-data'), z.literal('json'), z.literal('binaryData'), z.literal('raw'), expressionSchema]), required: false, displayOptions: {"show":{"sendBody":[true]}}, defaults: {"sendBody":false} }),
+    specifyBody: resolveOneOfSchemas({ parameters, variants: [{ schema: z.union([z.literal('keypair'), z.literal('json'), expressionSchema]), required: false, displayOptions: {"show":{"sendBody":[true],"contentType":["json"]}}, defaults: {"sendBody":false,"contentType":"json"} }, { schema: z.union([z.literal('keypair'), z.literal('string'), expressionSchema]), required: false, displayOptions: {"show":{"sendBody":[true],"contentType":["form-urlencoded"]}}, defaults: {"sendBody":false,"contentType":"json"} }] }),
+    bodyParameters: resolveOneOfSchemas({ parameters, variants: [{ schema: z.object({ parameters: z.array(z.object({ name: stringOrExpression.optional(), value: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"sendBody":[true],"contentType":["json"],"specifyBody":["keypair"]}}, defaults: {"sendBody":false,"contentType":"json","specifyBody":"keypair"} }, { schema: z.object({ parameters: z.array(z.object({ parameterType: z.union([z.literal('formBinaryData'), z.literal('formData'), expressionSchema]).optional(), name: stringOrExpression.optional(), value: stringOrExpression.optional(), inputDataFieldName: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"sendBody":[true],"contentType":["multipart-form-data"]}}, defaults: {"sendBody":false,"contentType":"json"} }, { schema: z.object({ parameters: z.array(z.object({ name: stringOrExpression.optional(), value: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"sendBody":[true],"contentType":["form-urlencoded"],"specifyBody":["keypair"]}}, defaults: {"sendBody":false,"contentType":"json","specifyBody":"keypair"} }] }),
+    jsonBody: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"sendBody":[true],"contentType":["json"],"specifyBody":["json"]}}, defaults: {"sendBody":false,"contentType":"json","specifyBody":"keypair"} }),
+    body: resolveOneOfSchemas({ parameters, variants: [{ schema: stringOrExpression, required: false, displayOptions: {"show":{"sendBody":[true],"specifyBody":["string"]}}, defaults: {"sendBody":false,"specifyBody":"keypair"} }, { schema: stringOrExpression, required: false, displayOptions: {"show":{"sendBody":[true],"contentType":["raw"]}}, defaults: {"sendBody":false,"contentType":"json"} }] }),
+    inputDataFieldName: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"sendBody":[true],"contentType":["binaryData"]}}, defaults: {"sendBody":false,"contentType":"json"} }),
+    rawContentType: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"sendBody":[true],"contentType":["raw"]}}, defaults: {"sendBody":false,"contentType":"json"} }),
+    options: z.object({ batching: z.object({ batch: z.object({ batchSize: numberOrExpression.optional(), batchInterval: numberOrExpression.optional() }).optional() }).optional(), allowUnauthorizedCerts: z.boolean().optional(), queryParameterArrays: z.union([z.literal('repeat'), z.literal('brackets'), z.literal('indices'), expressionSchema]).optional(), lowercaseHeaders: booleanOrExpression.optional(), redirect: z.object({ redirect: z.object({ followRedirects: z.boolean().optional(), maxRedirects: numberOrExpression.optional() }).optional() }).optional(), response: z.object({ response: z.object({ fullResponse: booleanOrExpression.optional(), neverError: booleanOrExpression.optional(), responseFormat: z.union([z.literal('autodetect'), z.literal('file'), z.literal('json'), z.literal('text')]).optional(), outputPropertyName: stringOrExpression.optional() }).optional() }).optional(), pagination: z.object({ pagination: z.object({ paginationMode: z.union([z.literal('off'), z.literal('updateAParameterInEachRequest'), z.literal('responseContainsNextURL'), expressionSchema]).optional(), nextURL: stringOrExpression.optional(), parameters: z.object({ parameters: z.array(z.object({ type: z.union([z.literal('body'), z.literal('headers'), z.literal('qs'), expressionSchema]).optional(), name: stringOrExpression.optional(), value: stringOrExpression.optional() })).optional() }).optional(), paginationCompleteWhen: z.union([z.literal('responseIsEmpty'), z.literal('receiveSpecificStatusCodes'), z.literal('other'), expressionSchema]).optional(), statusCodesWhenComplete: stringOrExpression.optional(), completeExpression: stringOrExpression.optional(), limitPagesFetched: z.boolean().optional(), maxRequests: numberOrExpression.optional(), requestInterval: numberOrExpression.optional() }).optional() }).optional(), proxy: stringOrExpression.optional(), timeout: numberOrExpression.optional(), sendCredentialsOnCrossOriginRedirect: booleanOrExpression.optional() }).optional(),
+    optimizeResponse: resolveSchema({ parameters, schema: z.boolean(), required: false, displayOptions: {"show":{"@tool":[true]}} }),
+    responseType: resolveSchema({ parameters, schema: z.union([z.literal('json'), z.literal('html'), z.literal('text'), expressionSchema]), required: false, displayOptions: {"show":{"optimizeResponse":[true],"@tool":[true]}}, defaults: {"optimizeResponse":false} }),
+    dataField: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"optimizeResponse":[true],"responseType":["json"],"@tool":[true]}}, defaults: {"optimizeResponse":false,"responseType":"json"} }),
+    fieldsToInclude: resolveSchema({ parameters, schema: z.union([z.literal('all'), z.literal('selected'), z.literal('except'), expressionSchema]), required: false, displayOptions: {"show":{"optimizeResponse":[true],"responseType":["json"],"@tool":[true]}}, defaults: {"optimizeResponse":false,"responseType":"json"} }),
+    fields: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"optimizeResponse":[true],"responseType":["json"],"@tool":[true]},"hide":{"fieldsToInclude":["all"]}}, defaults: {"optimizeResponse":false,"responseType":"json","fieldsToInclude":"all"} }),
+    cssSelector: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"optimizeResponse":[true],"responseType":["html"],"@tool":[true]}}, defaults: {"optimizeResponse":false,"responseType":"json"} }),
+    onlyContent: resolveSchema({ parameters, schema: booleanOrExpression, required: false, displayOptions: {"show":{"optimizeResponse":[true],"responseType":["html"],"@tool":[true]}}, defaults: {"optimizeResponse":false,"responseType":"json"} }),
+    elementsToOmit: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"optimizeResponse":[true],"responseType":["html"],"onlyContent":[true],"@tool":[true]}}, defaults: {"optimizeResponse":false,"responseType":"json","onlyContent":false} }),
+    truncateResponse: resolveSchema({ parameters, schema: booleanOrExpression, required: false, displayOptions: {"show":{"optimizeResponse":[true],"responseType":["text","html"],"@tool":[true]}}, defaults: {"optimizeResponse":false,"responseType":"json"} }),
+    maxLength: resolveSchema({ parameters, schema: numberOrExpression, required: false, displayOptions: {"show":{"optimizeResponse":[true],"responseType":["text","html"],"truncateResponse":[true],"@tool":[true]}}, defaults: {"optimizeResponse":false,"responseType":"json","truncateResponse":false} }),
+  });
+
+  // Return combined config schema
+  return z.object({
+    parameters: parametersSchema.nullable().optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-base/httpRequest/v45.ts

@@ -0,0 +1,425 @@
+/**
+ * HTTP Request Node - Version 4.5
+ * Makes an HTTP request and returns the response data
+ */
+
+
+export interface HttpRequestV45Params {
+/**
+ * The request method to use
+ * @default GET
+ */
+    method?: 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | Expression<string>;
+/**
+ * The URL to make the request to
+ */
+    url: string | Expression<string>;
+/**
+ * Authentication
+ * @builderHint Prefer "predefinedCredentialType" whenever n8n already ships a credential for the target service: it is less setup for the user and authenticates the request the same way. Look it up by the request URL rather than guessing. Use "genericCredentialType" only for services with no dedicated n8n credential. Keep "none" for unauthenticated requests and for inbound triggers.
+ * @default none
+ */
+    authentication?: 'none' | 'predefinedCredentialType' | 'genericCredentialType';
+/**
+ * Credential Type
+ * @displayOptions.show { authentication: ["predefinedCredentialType"] }
+ */
+    nodeCredentialType?: string;
+/**
+ * Generic Auth Type
+ * @builderHint Pick by how the API authenticates, not by what the user calls it:
+- "Authorization: Bearer &lt;token&gt;" → httpBearerAuth (single token field, best UX). Use this for OpenAI, Anthropic, GitHub PATs, Stripe, Notion, and any service whose docs say "Bearer".
+- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth (user must enter the header name and/or full value).
+- API key in the query string (?api_key=...) → httpQueryAuth.
+- username + password → httpBasicAuth.
+A user saying "API key" or "header auth" usually means httpBearerAuth only when the docs use the Authorization: Bearer &lt;token&gt; scheme. Use httpHeaderAuth for custom header names or non-Bearer Authorization schemes where the full header value/prefix must be user-controlled.
+ * @displayOptions.show { authentication: ["genericCredentialType"] }
+ */
+    genericAuthType?: 'httpBasicAuth' | 'httpBearerAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'httpCustomAuth' | 'oAuth1Api' | 'oAuth2Api' | Expression<string>;
+  provideSslCertificates?: boolean | Expression<boolean>;
+/**
+ * Whether the request has query params or not
+ * @default false
+ */
+    sendQuery?: boolean;
+/**
+ * Specify Query Parameters
+ * @displayOptions.show { sendQuery: [true] }
+ * @default keypair
+ */
+    specifyQuery?: 'keypair' | 'json' | Expression<string>;
+/**
+ * Query Parameters
+ * @displayOptions.show { sendQuery: [true], specifyQuery: ["keypair"] }
+ * @default {"parameters":[{"name":"","value":""}]}
+ */
+    queryParameters?: {
+        /** Query Parameter
+     * @builderHint NEVER put static authentication values (API keys, tokens, PATs) in queryParameters. It's insecure to store credentials directly in parameters. Instead set authentication to "genericCredentialType", genericAuthType to "httpQueryAuth", and add credentials: { httpQueryAuth:
+ newCredential("Name") }. Only use queryParameters for non-auth values. Dynamic values from previous nodes via expr() are acceptable.
+     */
+    parameters?: Array<{
+      /** Name
+       */
+      name?: string | Expression<string>;
+      /** Value
+       */
+      value?: string | Expression<string>;
+    }>;
+  };
+/**
+ * JSON
+ * @displayOptions.show { sendQuery: [true], specifyQuery: ["json"] }
+ */
+    jsonQuery?: IDataObject | string | Expression<string>;
+/**
+ * Whether the request has headers or not
+ * @default false
+ */
+    sendHeaders?: boolean;
+/**
+ * Specify Headers
+ * @displayOptions.show { sendHeaders: [true] }
+ * @default keypair
+ */
+    specifyHeaders?: 'keypair' | 'json' | Expression<string>;
+/**
+ * Headers
+ * @displayOptions.show { sendHeaders: [true], specifyHeaders: ["keypair"] }
+ * @default {"parameters":[{"name":"","value":""}]}
+ */
+    headerParameters?: {
+        /** Header
+     * @builderHint NEVER put static authentication values (API keys, tokens, PATs) in headerParameters. It's insecure to store credentials directly in parameters. Instead set authentication to "genericCredentialType", genericAuthType to "httpHeaderAuth", and add credentials: { httpHeaderAuth:
+ newCredential("Name") }. Only use headerParameters for non-auth headers like Content-Type or Accept. Dynamic values from previous nodes via expr() are acceptable.
+     */
+    parameters?: Array<{
+      /** Name
+       */
+      name?: string | Expression<string>;
+      /** Value
+       */
+      value?: string | Expression<string>;
+    }>;
+  };
+/**
+ * JSON
+ * @displayOptions.show { sendHeaders: [true], specifyHeaders: ["json"] }
+ */
+    jsonHeaders?: IDataObject | string | Expression<string>;
+/**
+ * Whether the request has a body or not
+ * @default false
+ */
+    sendBody?: boolean;
+/**
+ * Content-Type to use to send body parameters
+ * @displayOptions.show { sendBody: [true] }
+ * @default json
+ */
+    contentType?: 'form-urlencoded' | 'multipart-form-data' | 'json' | 'binaryData' | 'raw' | Expression<string>;
+/**
+ * The body can be specified using explicit fields (&lt;code&gt;keypair&lt;/code&gt;) or using a JavaScript object (&lt;code&gt;json&lt;/code&gt;)
+ * @displayOptions.show { sendBody: [true], contentType: ["json"] }
+ * @default keypair
+ */
+    specifyBody?: 'keypair' | 'json' | Expression<string>;
+/**
+ * Body Parameters
+ * @builderHint NEVER put static authentication values (API keys, tokens, PATs) in bodyParameters. It's insecure to store credentials directly in parameters. Instead set authentication to "genericCredentialType", genericAuthType to "customAuth", and add credentials: { customAuth:
+ newCredential("Name") }. Only use bodyParameters for non-auth values. Dynamic values from previous nodes via expr() are acceptable.
+ * @displayOptions.show { sendBody: [true], contentType: ["json"], specifyBody: ["keypair"] }
+ * @default {"parameters":[{"name":"","value":""}]}
+ */
+    bodyParameters?: {
+        /** Body Field
+     */
+    parameters?: Array<{
+      /** ID of the field to set. Choose from the list, or specify an ID using an &lt;a href="https://docs.n8n.io/code/expressions/"&gt;expression&lt;/a&gt;.
+       */
+      name?: string | Expression<string>;
+      /** Value of the field to set
+       */
+      value?: string | Expression<string>;
+    }>;
+  };
+/**
+ * JSON
+ * @builderHint NEVER put static authentication values (API keys, tokens, PATs) in bodyParameters. It's insecure to store credentials directly in parameters. Instead set authentication to "genericCredentialType", genericAuthType to "customAuth", and add credentials: { customAuth:
+ newCredential("Name") }. Only use bodyParameters for non-auth values. Dynamic values from previous nodes via expr() are acceptable.
+ * @displayOptions.show { sendBody: [true], contentType: ["json"], specifyBody: ["json"] }
+ */
+    jsonBody?: IDataObject | string | Expression<string>;
+/**
+ * Body
+ * @displayOptions.show { sendBody: [true], specifyBody: ["string"] }
+ */
+    body?: string | Expression<string>;
+/**
+ * The name of the incoming field containing the binary file data to be processed
+ * @displayOptions.show { sendBody: [true], contentType: ["binaryData"] }
+ */
+    inputDataFieldName?: string | Expression<string>;
+/**
+ * Content Type
+ * @displayOptions.show { sendBody: [true], contentType: ["raw"] }
+ */
+    rawContentType?: string | Expression<string>;
+  options?: {
+    /** Batching
+     * @default {"batch":{}}
+     */
+    batching?: {
+        /** Batching
+     */
+    batch?: {
+      /** Input will be split in batches to throttle requests. -1 for disabled. 0 will be treated as 1.
+       * @default 50
+       */
+      batchSize?: number | Expression<number>;
+      /** Time (in milliseconds) between each batch of requests. 0 for disabled.
+       * @default 1000
+       */
+      batchInterval?: number | Expression<number>;
+    };
+  };
+    /** Whether to download the response even if SSL certificate validation is not possible
+     * @default false
+     */
+    allowUnauthorizedCerts?: boolean;
+    /** Array Format in Query Parameters
+     * @displayOptions.show { /sendQuery: [true] }
+     * @default brackets
+     */
+    queryParameterArrays?: 'repeat' | 'brackets' | 'indices' | Expression<string>;
+    /** Whether to lowercase header names
+     * @default true
+     */
+    lowercaseHeaders?: boolean | Expression<boolean>;
+    /** Redirects
+     * @default {"redirect":{}}
+     */
+    redirect?: {
+        /** Redirect
+     */
+    redirect?: {
+      /** Whether to follow all redirects
+       * @default false
+       */
+      followRedirects?: boolean;
+      /** Max number of redirects to follow
+       * @displayOptions.show { followRedirects: [true] }
+       * @default 21
+       */
+      maxRedirects?: number | Expression<number>;
+    };
+  };
+    /** Redirects
+     * @default {"redirect":{}}
+     */
+    redirect?: {
+        /** Redirect
+     */
+    redirect?: {
+      /** Whether to follow all redirects
+       * @default true
+       */
+      followRedirects?: boolean;
+      /** Max number of redirects to follow
+       * @displayOptions.show { followRedirects: [true] }
+       * @default 21
+       */
+      maxRedirects?: number | Expression<number>;
+    };
+  };
+    /** Response
+     * @default {"response":{}}
+     */
+    response?: {
+        /** Response
+     */
+    response?: {
+      /** Whether to return the full response (headers and response status code) data instead of only the body
+       * @default false
+       */
+      fullResponse?: boolean | Expression<boolean>;
+      /** Whether to succeeds also when status code is not 2xx
+       * @default false
+       */
+      neverError?: boolean | Expression<boolean>;
+      /** The format in which the data gets returned from the URL
+       * @default autodetect
+       */
+      responseFormat?: 'autodetect' | 'file' | 'json' | 'text';
+      /** Name of the binary property to which to write the data of the read file
+       * @displayOptions.show { responseFormat: ["file", "text"] }
+       * @default data
+       */
+      outputPropertyName?: string | Expression<string>;
+    };
+  };
+    /** Pagination
+     * @default {"pagination":{}}
+     */
+    pagination?: {
+        /** Pagination
+     */
+    pagination?: {
+      /** If pagination should be used
+       * @default updateAParameterInEachRequest
+       */
+      paginationMode?: 'off' | 'updateAParameterInEachRequest' | 'responseContainsNextURL' | Expression<string>;
+      /** Should evaluate to the URL of the next page. &lt;a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/#pagination" target="_blank"&gt;More info&lt;/a&gt;.
+       * @displayOptions.show { paginationMode: ["responseContainsNextURL"] }
+       */
+      nextURL?: string | Expression<string>;
+      /** Parameters
+       * @displayOptions.show { paginationMode: ["updateAParameterInEachRequest"] }
+       * @default {"parameters":[{"type":"qs","name":"","value":""}]}
+       */
+      parameters?: {
+        /** Parameter
+     */
+    parameters?: Array<{
+      /** Where the parameter should be set
+       * @default qs
+       */
+      type?: 'body' | 'headers' | 'qs' | Expression<string>;
+      /** Name
+       */
+      name?: string | Expression<string>;
+      /** Value
+       * @hint Use expression mode and $response to access response data
+       */
+      value?: string | Expression<string>;
+    }>;
+  };
+      /** When should no further requests be made?
+       * @displayOptions.hide { paginationMode: ["off"] }
+       * @default responseIsEmpty
+       */
+      paginationCompleteWhen?: 'responseIsEmpty' | 'receiveSpecificStatusCodes' | 'other' | Expression<string>;
+      /** Accepts comma-separated values
+       * @displayOptions.show { paginationCompleteWhen: ["receiveSpecificStatusCodes"] }
+       */
+      statusCodesWhenComplete?: string | Expression<string>;
+      /** Should evaluate to true when pagination is complete. &lt;a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/#pagination" target="_blank"&gt;More info&lt;/a&gt;.
+       * @displayOptions.show { paginationCompleteWhen: ["other"] }
+       */
+      completeExpression?: string | Expression<string>;
+      /** Whether the number of requests should be limited
+       * @displayOptions.hide { paginationMode: ["off"] }
+       * @default false
+       */
+      limitPagesFetched?: boolean;
+      /** Maximum amount of request to be make
+       * @displayOptions.show { limitPagesFetched: [true] }
+       * @default 100
+       */
+      maxRequests?: number | Expression<number>;
+      /** Time in milliseconds to wait between requests
+       * @hint At 0 no delay will be added
+       * @displayOptions.hide { paginationMode: ["off"] }
+       * @default 0
+       */
+      requestInterval?: number | Expression<number>;
+    };
+  };
+    /** HTTP proxy to use
+     */
+    proxy?: string | Expression<string>;
+    /** Time in ms to wait for the server to send response headers (and start the response body) before aborting the request
+     * @default 10000
+     */
+    timeout?: number | Expression<number>;
+    /** Whether to send credentials, like the "Authorization" header, on redirects to a different origin
+     * @default false
+     */
+    sendCredentialsOnCrossOriginRedirect?: boolean | Expression<boolean>;
+  };
+/**
+ * Whether the optimize the tool response to reduce amount of data passed to the LLM that could lead to better result and reduce cost
+ * @displayOptions.show { @tool: [true] }
+ * @default false
+ */
+    optimizeResponse?: boolean;
+/**
+ * Expected Response Type
+ * @displayOptions.show { optimizeResponse: [true], @tool: [true] }
+ * @default json
+ */
+    responseType?: 'json' | 'html' | 'text' | Expression<string>;
+/**
+ * Specify the name of the field in the response containing the data
+ * @hint leave blank to use whole response
+ * @displayOptions.show { optimizeResponse: [true], responseType: ["json"], @tool: [true] }
+ */
+    dataField?: string | Expression<string>;
+/**
+ * What fields response object should include
+ * @displayOptions.show { optimizeResponse: [true], responseType: ["json"], @tool: [true] }
+ * @default all
+ */
+    fieldsToInclude?: 'all' | 'selected' | 'except' | Expression<string>;
+/**
+ * Comma-separated list of the field names. Supports dot notation. You can drag the selected fields from the input panel.
+ * @displayOptions.show { optimizeResponse: [true], responseType: ["json"], @tool: [true] }
+ * @displayOptions.hide { fieldsToInclude: ["all"] }
+ */
+    fields?: string | Expression<string>;
+/**
+ * Select specific element(e.g. body) or multiple elements(e.g. div) of chosen type in the response HTML.
+ * @displayOptions.show { optimizeResponse: [true], responseType: ["html"], @tool: [true] }
+ * @default body
+ */
+    cssSelector?: string | Expression<string>;
+/**
+ * Whether to return only content of html elements, stripping html tags and attributes
+ * @hint Uses less tokens and may be easier for model to understand
+ * @displayOptions.show { optimizeResponse: [true], responseType: ["html"], @tool: [true] }
+ * @default false
+ */
+    onlyContent?: boolean | Expression<boolean>;
+/**
+ * Comma-separated list of selectors that would be excluded when extracting content
+ * @displayOptions.show { optimizeResponse: [true], responseType: ["html"], onlyContent: [true], @tool: [true] }
+ */
+    elementsToOmit?: string | Expression<string>;
+/**
+ * Truncate Response
+ * @hint Helps save tokens
+ * @displayOptions.show { optimizeResponse: [true], responseType: ["text", "html"], @tool: [true] }
+ * @default false
+ */
+    truncateResponse?: boolean | Expression<boolean>;
+/**
+ * Max Response Characters
+ * @displayOptions.show { optimizeResponse: [true], responseType: ["text", "html"], truncateResponse: [true], @tool: [true] }
+ * @default 1000
+ */
+    maxLength?: number | Expression<number>;
+}
+
+export interface HttpRequestV45Credentials {
+  httpSslAuth: CredentialReference;
+  /** Generic auth credentials - set the 'genericAuthType' config parameter to select which one to use */
+  httpBasicAuth?: CredentialReference;
+  httpBearerAuth?: CredentialReference;
+  httpDigestAuth?: CredentialReference;
+  httpHeaderAuth?: CredentialReference;
+  httpQueryAuth?: CredentialReference;
+  httpCustomAuth?: CredentialReference;
+  oAuth1Api?: CredentialReference;
+  oAuth2Api?: CredentialReference;
+}
+
+interface HttpRequestV45NodeBase {
+  type: 'n8n-nodes-base.httpRequest';
+  version: 4.5;
+}
+
+export type HttpRequestV45ParamsNode = HttpRequestV45NodeBase & {
+  config: NodeConfig<HttpRequestV45Params> & { credentials?: HttpRequestV45Credentials };
+};
+
+export type HttpRequestV45Node = HttpRequestV45ParamsNode;

package/dist/node-definitions/nodes/n8n-nodes-base/hubspot/v22/resource_company/operation_delete.ts

@@ -23,8 +23,13 @@ export type HubspotV22CompanyDeleteParams = {
     companyId?: { __rl: true; mode: 'list' | 'id'; value: string; cachedResultName?: string };
 };
 
+export type HubspotV22CompanyDeleteOutput = {
+  deleted?: boolean;
+};
+
 export type HubspotV22CompanyDeleteNode = {
   type: 'n8n-nodes-base.hubspot';
   version: 2.2;
   config: NodeConfig<HubspotV22CompanyDeleteParams> & { credentials?: Credentials };
+  output?: Items<HubspotV22CompanyDeleteOutput>;
 };

package/dist/node-definitions/nodes/n8n-nodes-base/hubspot/v22/resource_company/operation_get_all.ts

@@ -67,10 +67,12 @@ export type HubspotV22CompanyGetAllOutput = {
       value?: string;
       versions?: Array<{
         name?: string;
+        persistenceTimestamp?: number;
         requestId?: string;
         source?: string;
         sourceId?: string;
         sourceUpstreamDeployable?: string;
+        sourceVid?: Array<number>;
         timestamp?: number;
         updatedByUserId?: number;
         useTimestampAsPersistenceTimestamp?: boolean;

package/dist/node-definitions/nodes/n8n-nodes-base/hubspot/v22/resource_deal/operation_get_all.ts

@@ -71,6 +71,22 @@ export type HubspotV22DealGetAllOutput = {
   isDeleted?: boolean;
   portalId?: number;
   properties?: {
+    dealname?: {
+      source?: string;
+      timestamp?: number;
+      value?: string;
+      versions?: Array<{
+        name?: string;
+        requestId?: string;
+        source?: string;
+        sourceId?: string;
+        sourceUpstreamDeployable?: string;
+        timestamp?: number;
+        updatedByUserId?: number;
+        useTimestampAsPersistenceTimestamp?: boolean;
+        value?: string;
+      }>;
+    };
     dealstage?: {
       source?: string;
       sourceId?: string;

package/dist/node-definitions/nodes/n8n-nodes-base/hubspot/v22/resource_ticket/operation_get.ts

@@ -63,6 +63,7 @@ export type HubspotV22TicketGetOutput = {
         source?: string;
         sourceId?: string;
         sourceUpstreamDeployable?: string;
+        sourceVid?: Array<number>;
         timestamp?: number;
         updatedByUserId?: number;
         useTimestampAsPersistenceTimestamp?: boolean;

package/dist/node-definitions/nodes/n8n-nodes-base/jira/v1/resource_issue/operation_get.ts

@@ -389,6 +389,45 @@ export type JiraV1IssueGetOutput = {
       maxResults?: number;
       startAt?: number;
       total?: number;
+      worklogs?: Array<{
+        author?: {
+          accountId?: string;
+          accountType?: string;
+          active?: boolean;
+          avatarUrls?: {
+            '16x16'?: string;
+            '24x24'?: string;
+            '32x32'?: string;
+            '48x48'?: string;
+          };
+          displayName?: string;
+          self?: string;
+          timeZone?: string;
+        };
+        comment?: string;
+        created?: string;
+        id?: string;
+        issueId?: string;
+        self?: string;
+        started?: string;
+        timeSpent?: string;
+        timeSpentSeconds?: number;
+        updateAuthor?: {
+          accountId?: string;
+          accountType?: string;
+          active?: boolean;
+          avatarUrls?: {
+            '16x16'?: string;
+            '24x24'?: string;
+            '32x32'?: string;
+            '48x48'?: string;
+          };
+          displayName?: string;
+          self?: string;
+          timeZone?: string;
+        };
+        updated?: string;
+      }>;
     };
     workratio?: number;
   };

package/dist/node-definitions/nodes/n8n-nodes-base/jira/v1/resource_issue/operation_get_all.ts

@@ -227,6 +227,12 @@ export type JiraV1IssueGetAllOutput = {
       id?: string;
       key?: string;
       name?: string;
+      projectCategory?: {
+        description?: string;
+        id?: string;
+        name?: string;
+        self?: string;
+      };
       projectTypeKey?: string;
       self?: string;
       simplified?: boolean;

package/dist/node-definitions/nodes/n8n-nodes-base/jira/v1/resource_issue_attachment/operation_get.ts

@@ -54,6 +54,7 @@ export type JiraV1IssueAttachmentGetOutput = {
   mimeType?: string;
   self?: string;
   size?: number;
+  thumbnail?: string;
 };
 
 export type JiraV1IssueAttachmentGetNode = {

package/dist/node-definitions/nodes/n8n-nodes-base/lemlist/v2/resource_campaign/operation_get_all.ts

@@ -36,9 +36,11 @@ export type LemlistV2CampaignGetAllParams = {
 
 export type LemlistV2CampaignGetAllOutput = {
   _id?: string;
+  archived?: boolean;
   createdAt?: string;
   createdBy?: string;
   name?: string;
+  sequenceId?: string;
   status?: string;
 };
 

package/dist/node-definitions/nodes/n8n-nodes-base/mailchimp/v1/resource_campaign/operation_get_all.ts

@@ -109,7 +109,10 @@ export type MailchimpV1CampaignGetAllOutput = {
     clicks?: number;
     ecommerce?: {
       total_orders?: number;
+      total_revenue?: number;
+      total_spent?: number;
     };
+    open_rate?: number;
     opens?: number;
     subscriber_clicks?: number;
     unique_opens?: number;

package/dist/node-definitions/nodes/n8n-nodes-base/mailchimp/v1/resource_member/operation_delete.ts

@@ -27,6 +27,7 @@ export type MailchimpV1MemberDeleteParams = {
 
 export type MailchimpV1MemberDeleteOutput = {
   error?: string;
+  success?: boolean;
 };
 
 export type MailchimpV1MemberDeleteNode = {