n8n-nodes-base 2.32.2 → 2.33.0

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/microsoftExcelSharePoint/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Microsoft Excel (SharePoint) Node Types
+ *
+ * Re-exports all version-specific types and provides combined union type.
+ */
+
+import type { MicrosoftExcelSharePointV1Node } from './v1';
+
+export * from './v1';
+
+// Combined union type for all versions
+export type MicrosoftExcelSharePointNode = MicrosoftExcelSharePointV1Node;

package/dist/node-definitions/nodes/n8n-nodes-base/microsoftExcelSharePoint/v1/index.schema.js

@@ -0,0 +1,24 @@
+/**
+ * Microsoft Excel (SharePoint) Node - Version 1 - Zod Schema Factory
+ * Exports a factory that unions all discriminator schemas.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+const getWorksheetSchema = require('./resource_worksheet/index.schema');
+const getTableSchema = require('./resource_table/index.schema');
+const getWorkbookSchema = require('./resource_workbook/index.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply discriminator default if not set
+  const effectiveParams = parameters.resource === undefined ? { ...parameters, resource: 'worksheet' } : parameters;
+  return z.union([
+    getWorksheetSchema({ ...helpers, parameters: effectiveParams }),
+    getTableSchema({ ...helpers, parameters: effectiveParams }),
+    getWorkbookSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

package/dist/node-definitions/nodes/n8n-nodes-base/microsoftExcelSharePoint/v1/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Microsoft Excel (SharePoint) Node - Version 1
+ * Re-exports all discriminator combinations.
+ */
+
+import type { MicrosoftExcelSharePointV1WorksheetNode } from './resource_worksheet';
+import type { MicrosoftExcelSharePointV1TableNode } from './resource_table';
+import type { MicrosoftExcelSharePointV1WorkbookNode } from './resource_workbook';
+
+export * from './resource_worksheet';
+export * from './resource_table';
+export * from './resource_workbook';
+
+export type MicrosoftExcelSharePointV1Node =
+  | MicrosoftExcelSharePointV1WorksheetNode
+  | MicrosoftExcelSharePointV1TableNode
+  | MicrosoftExcelSharePointV1WorkbookNode
+  ;

package/dist/node-definitions/nodes/n8n-nodes-base/microsoftExcelSharePoint/v1/resource_table/index.schema.js

@@ -0,0 +1,34 @@
+/**
+ * Microsoft Excel (SharePoint) - Table Resource - Zod Schema Factory
+ * Exports a factory that unions all operation schemas for this resource.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+const getAppendSchema = require('./operation_append.schema');
+const getConvertToRangeSchema = require('./operation_convert_to_range.schema');
+const getCreateSchema = require('./operation_create.schema');
+const getDeleteTableSchema = require('./operation_delete_table.schema');
+const getGetAllSchema = require('./operation_get_all.schema');
+const getGetColumnsSchema = require('./operation_get_columns.schema');
+const getGetRowsSchema = require('./operation_get_rows.schema');
+const getLookupSchema = require('./operation_lookup.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply operation default if not set
+  const effectiveParams = parameters.operation === undefined ? { ...parameters, operation: 'readRows' } : parameters;
+  return z.union([
+    getAppendSchema({ ...helpers, parameters: effectiveParams }),
+    getConvertToRangeSchema({ ...helpers, parameters: effectiveParams }),
+    getCreateSchema({ ...helpers, parameters: effectiveParams }),
+    getDeleteTableSchema({ ...helpers, parameters: effectiveParams }),
+    getGetAllSchema({ ...helpers, parameters: effectiveParams }),
+    getGetColumnsSchema({ ...helpers, parameters: effectiveParams }),
+    getGetRowsSchema({ ...helpers, parameters: effectiveParams }),
+    getLookupSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

package/dist/node-definitions/nodes/n8n-nodes-base/microsoftExcelSharePoint/v1/resource_table/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Microsoft Excel (SharePoint) - Table Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { MicrosoftExcelSharePointV1TableAppendNode } from './operation_append';
+import type { MicrosoftExcelSharePointV1TableConvertToRangeNode } from './operation_convert_to_range';
+import type { MicrosoftExcelSharePointV1TableCreateNode } from './operation_create';
+import type { MicrosoftExcelSharePointV1TableDeleteTableNode } from './operation_delete_table';
+import type { MicrosoftExcelSharePointV1TableGetAllNode } from './operation_get_all';
+import type { MicrosoftExcelSharePointV1TableGetColumnsNode } from './operation_get_columns';
+import type { MicrosoftExcelSharePointV1TableGetRowsNode } from './operation_get_rows';
+import type { MicrosoftExcelSharePointV1TableLookupNode } from './operation_lookup';
+
+export * from './operation_append';
+export * from './operation_convert_to_range';
+export * from './operation_create';
+export * from './operation_delete_table';
+export * from './operation_get_all';
+export * from './operation_get_columns';
+export * from './operation_get_rows';
+export * from './operation_lookup';
+
+export type MicrosoftExcelSharePointV1TableNode =
+  | MicrosoftExcelSharePointV1TableAppendNode
+  | MicrosoftExcelSharePointV1TableConvertToRangeNode
+  | MicrosoftExcelSharePointV1TableCreateNode
+  | MicrosoftExcelSharePointV1TableDeleteTableNode
+  | MicrosoftExcelSharePointV1TableGetAllNode
+  | MicrosoftExcelSharePointV1TableGetColumnsNode
+  | MicrosoftExcelSharePointV1TableGetRowsNode
+  | MicrosoftExcelSharePointV1TableLookupNode
+  ;

package/dist/node-definitions/nodes/n8n-nodes-base/microsoftExcelSharePoint/v1/resource_table/operation_append.schema.js

@@ -0,0 +1,31 @@
+/**
+ * Microsoft Excel (SharePoint) Node - Version 1 - Zod Schema
+ * Discriminator: resource=table, operation=append
+ *
+ * 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 }) {
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('table'),
+      operation: z.literal('append'),
+      authentication: z.union([z.literal('microsoftOAuth2Api'), z.literal('microsoftEntraServicePrincipalApi')]).optional(),
+      site: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('url'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+      library: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+      workbook: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('url'), z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+      worksheet: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+      table: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+      dataMode: z.union([z.literal('autoMap'), z.literal('define'), z.literal('raw'), expressionSchema]).optional(),
+      data: resolveSchema({ parameters, schema: z.union([iDataObjectSchema, z.string()]), required: false, displayOptions: {"show":{"dataMode":["raw"]}}, defaults: {"dataMode":"define"} }),
+      fieldsUi: resolveSchema({ parameters, schema: z.object({ values: z.array(z.object({ column: stringOrExpression.optional(), fieldValue: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"dataMode":["define"]}}, defaults: {"dataMode":"define"} }),
+      options: z.object({ index: numberOrExpression.optional(), rawData: booleanOrExpression.optional(), dataProperty: stringOrExpression.optional() }).optional(),
+    }).optional(),
+  });
+};