@stackone/core 2.75.1 → 2.77.0

package/dist/index.d.cts

@@ -1,12 +1,10 @@
-import http from "node:http";
-import https from "node:https";
-import { Readable } from "node:stream";
-import * as zod_v40 from "zod/v4";
-import { ZodType, z } from "zod/v4";
-import * as zod_v4_core0 from "zod/v4/core";
+import { IOlapClient } from "@stackone/olap";
+import { ConcurrencyConfig, HttpHeaders, HttpMethod, IHttpClient, RateLimitConfig, SigningOptions } from "@stackone/transport";
+import { ZodType, z } from "@stackone/utils";
 import { LambdaClient, LambdaClientConfig } from "@aws-sdk/client-lambda";
+import { Readable } from "node:stream";
 
-//#region rolldown:runtime
+//#region \0rolldown/runtime.js
 //#endregion
 //#region ../logger/src/types.d.ts
 interface ILogger {
@@ -71,775 +69,6 @@ type LogError = Error & {
   url?: string;
 };
 //#endregion
-//#region ../transport/src/concurrencyManager/types.d.ts
-type ConcurrencySubPoolConfig = {
-  subPoolKey: string;
-  urlPattern: RegExp | string;
-  maxConcurrency: number;
-};
-type ConcurrencyConfig = {
-  mainMaxConcurrency: number;
-  subPools?: ConcurrencySubPoolConfig[];
-};
-//#endregion
-//#region ../transport/src/rateLimitManager/types.d.ts
-type RateLimitSubPoolConfig = {
-  subPoolKey: string;
-  urlPattern: RegExp | string;
-  rateLimit: number;
-};
-type RetryUnit = 'seconds' | 'milliseconds' | 'date';
-type MappedRateLimitErrorConfig = {
-  errorStatus: number;
-  errorMessage: string | RegExp;
-  errorMessagePath?: string;
-  retryAfterPath?: string;
-  retryAfterUnit?: RetryUnit;
-  retryAfterValue?: number;
-};
-type RateLimitConfig = {
-  mainRatelimit: number;
-  subPools?: RateLimitSubPoolConfig[];
-  mappedRateLimitErrors?: MappedRateLimitErrorConfig[];
-};
-//#endregion
-//#region ../transport/src/interceptors/types.d.ts
-type RequestConfig = {
-  rateLimits?: RateLimitConfig;
-  concurrency?: ConcurrencyConfig;
-};
-//#endregion
-//#region ../transport/src/parsers/types.d.ts
-declare const QueryArrayFormats: readonly ["repeat", "brackets", "comma", "stringify"];
-type QueryArrayFormat = (typeof QueryArrayFormats)[number];
-//#endregion
-//#region ../transport/src/httpClient/types.d.ts
-type HttpHeader = string | string[];
-type HttpHeaders = {
-  [key: string]: HttpHeader;
-};
-type HttpQueryParamValue = {
-  value: string | string[];
-  arrayFormat?: QueryArrayFormat;
-};
-type HttpQueryParams = {
-  [key: string]: string | string[] | HttpQueryParamValue;
-};
-declare const HttpMethods: readonly ["get", "post", "put", "delete", "patch"];
-type HttpMethod = (typeof HttpMethods)[number];
-type HttpResponse<T = any, P$1 = any> = {
-  data: T;
-  status: number;
-  headers: HttpHeaders;
-  requestUrl: string;
-  responseType?: string;
-  responseTime?: Date;
-  message?: string;
-  body?: P$1;
-};
-type StreamHttpResponse = {
-  status: number;
-  headers: HttpHeaders;
-  stream: Readable;
-  requestUrl: string;
-};
-interface IHttpClient {
-  request<P$1, T>({
-    headers,
-    url,
-    method,
-    queryParams,
-    maxRedirects,
-    responseType,
-    cacheTTL,
-    context,
-    payload,
-    httpsAgent,
-    httpAgent,
-    requestConfig,
-    httpsAgentConfig
-  }: {
-    headers?: HttpHeaders;
-    url: string;
-    method?: HttpMethod;
-    queryParams?: HttpQueryParams;
-    maxRedirects?: number;
-    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
-    cacheTTL?: number;
-    context?: RequestContext;
-    payload?: P$1;
-    httpsAgent?: https.Agent;
-    httpAgent?: http.Agent;
-    requestConfig?: RequestConfig;
-    httpsAgentConfig?: https.AgentOptions;
-  }): Promise<HttpResponse<T>>;
-  get<T>({
-    headers,
-    url,
-    queryParams,
-    maxRedirects,
-    cacheTTL,
-    context,
-    requestConfig
-  }: {
-    headers?: HttpHeaders;
-    url: string;
-    queryParams?: HttpQueryParams;
-    maxRedirects?: number;
-    cacheTTL?: number;
-    context?: RequestContext;
-    requestConfig?: RequestConfig;
-  }): Promise<HttpResponse<T>>;
-  post<P$1, T>({
-    headers,
-    url,
-    maxRedirects,
-    cacheTTL,
-    context,
-    payload,
-    requestConfig
-  }: {
-    headers?: HttpHeaders;
-    url: string;
-    maxRedirects?: number;
-    cacheTTL?: number;
-    context?: RequestContext;
-    payload?: P$1;
-    requestConfig?: RequestConfig;
-  }): Promise<HttpResponse<T>>;
-  requestStream({
-    headers,
-    url,
-    method,
-    queryParams,
-    maxRedirects,
-    context,
-    traceId,
-    payload,
-    httpsAgent,
-    httpAgent,
-    requestConfig,
-    httpsAgentConfig
-  }: {
-    headers?: HttpHeaders;
-    url: string;
-    method?: HttpMethod;
-    queryParams?: HttpQueryParams;
-    maxRedirects?: number;
-    context?: RequestContext;
-    traceId?: string;
-    payload?: unknown;
-    httpsAgent?: https.Agent;
-    httpAgent?: http.Agent;
-    requestConfig?: RequestConfig;
-    httpsAgentConfig?: https.AgentOptions;
-  }): Promise<StreamHttpResponse>;
-}
-interface OperationSetting {
-  url?: string;
-  query?: Record<string, string>;
-  config?: Partial<APIConfig>;
-  custom_settings?: Record<string, unknown>;
-}
-type OperationSettings = Record<string, OperationSetting>;
-type AccountSettings = Record<string, string | number | boolean | object>;
-type HttpClientBehaviour = 'CONCURRENCY' | 'RETRY';
-type APIConfig = Record<string, unknown>;
-type RequestContext = {
-  accountSecureId?: string;
-  projectSecureId?: string;
-  organizationId?: number | string;
-  environment?: string;
-  authConfigKey?: string;
-  provider?: string;
-  service?: string;
-  resource?: string;
-  subResource?: string;
-  childResource?: string;
-  operation?: string;
-  action?: string;
-  mode?: string;
-  testerUniqueToken?: string;
-  externalKey?: string;
-  dataKey?: string;
-  isDataSync?: boolean;
-  operationSettings?: OperationSettings;
-  accountSettings?: AccountSettings;
-  behaviours?: HttpClientBehaviour[];
-};
-//#endregion
-//#region ../transport/src/signing/types.d.ts
-type Aws4SigningOptions = {
-  strategy: 'aws4';
-  service: string;
-  region?: string;
-};
-type HmacSigningOptions = {
-  strategy: 'hmac';
-  algorithm?: 'sha256' | 'sha512';
-  headerName?: string;
-  prefix?: string;
-};
-type SigningOptions = Aws4SigningOptions | HmacSigningOptions;
-//#endregion
-//#region ../olap/src/olap/olapOptions.d.ts
-type OlapOptions = {
-  logs?: LogsOptions;
-  advanced?: AdvancedOptions;
-  defender?: DefenderOptions;
-  datasets?: DatasetsOptions;
-};
-type LogsOptions = {
-  enabled?: boolean;
-};
-type AdvancedOptions = {
-  enabled?: boolean;
-  ttl?: number;
-  errorsOnly?: boolean;
-  includeBackground?: boolean;
-};
-type DefenderOptions = {
-  enabled?: boolean;
-};
-type DatasetsOptions = {
-  enabled?: boolean;
-  includeBackground?: boolean;
-};
-//#endregion
-//#region ../olap/src/advanced/types.d.ts
-type ActionAdvancedLog = {
-  data: {
-    [key: string]: unknown;
-  };
-  metadata?: {
-    isBackgroundLog?: boolean;
-    expirationTime?: number;
-  };
-};
-type StepAdvancedLog = {
-  data: {
-    [key: string]: unknown;
-  };
-  metadata?: {
-    expirationTime?: number;
-  };
-};
-type UnifiedAdvancedLog = {
-  data: {
-    [key: string]: unknown;
-  };
-  metadata?: {
-    isBackgroundLog?: boolean;
-    expirationTime?: number;
-  };
-};
-type ProviderAdvancedLog = {
-  data: {
-    [key: string]: unknown;
-  };
-  metadata?: {
-    expirationTime?: number;
-  };
-};
-//#endregion
-//#region ../olap/src/defender/types.d.ts
-type DefenderLog = {
-  result?: {
-    riskLevel: string;
-    tier2Score?: number;
-    [key: string]: unknown;
-  };
-  [key: string]: unknown;
-};
-//#endregion
-//#region ../olap/src/types.d.ts
-interface IOlapClient {
-  recordAction(actionInput: ActionInput, actionResult: ActionResult, options?: OlapOptions): Promise<void>;
-  recordActions(actions: Array<{
-    input: ActionInput;
-    result: ActionResult;
-  }>, options?: OlapOptions): Promise<void>;
-  recordStep(stepInput: StepInput, stepResult: StepResult, options?: OlapOptions): Promise<void>;
-  recordSteps(steps: Array<{
-    input: StepInput;
-    result: StepResult;
-  }>, options?: OlapOptions): Promise<void>;
-  recordUnified(unifiedInput: UnifiedInput, unifiedResult: UnifiedResult, options?: OlapOptions): Promise<void>;
-  recordProvider(providerInput: ProviderInput, providerResult: ProviderResult, options?: OlapOptions): Promise<void>;
-  getLogs(organizationId: string, projectSecureId: string, query: Query): Promise<QueryResult>;
-  getActionLogs(organizationId: string, projectSecureId: string, query: ActionsQuery): Promise<ActionsQueryResult>;
-  getActionLog(organizationId: string, projectSecureId: string, actionRunId: string): Promise<ActionLog | undefined>;
-  getLog(organizationId: string, projectSecureId: string, logId: string): Promise<ActionLog | UnifiedLog | undefined>;
-  getStepLogs(organizationId: string, projectSecureId: string, query: StepsQuery): Promise<StepsQueryResult>;
-  getStepLog(organizationId: string, projectSecureId: string, actionRunId: string, stepIndex: number): Promise<StepLog | undefined>;
-  getUnifiedLogs(organizationId: string, projectSecureId: string, query: UnifiedQuery): Promise<UnifiedQueryResult>;
-  getUnifiedLog(organizationId: string, projectSecureId: string, requestId: string): Promise<UnifiedLog | undefined>;
-  getProviderLogs(organizationId: string, projectSecureId: string, query: ProviderQuery): Promise<ProviderQueryResult>;
-  getProviderLog(organizationId: string, projectSecureId: string, requestId: string, id: string): Promise<ProviderLog | undefined>;
-  getActionAdvancedLog(organizationId: string, projectSecureId: string, actionRunId: string): Promise<ActionAdvancedLog | undefined>;
-  getStepAdvancedLog(organizationId: string, projectSecureId: string, actionRunId: string, stepIndex: number): Promise<StepAdvancedLog | undefined>;
-  getUnifiedAdvancedLog(organizationId: string, projectSecureId: string, requestId: string): Promise<UnifiedAdvancedLog | undefined>;
-  getProviderAdvancedLog(organizationId: string, projectSecureId: string, requestId: string, id: string): Promise<ProviderAdvancedLog | undefined>;
-  getDefenderLog(organizationId: string, projectSecureId: string, actionRunId: string): Promise<DefenderLog | undefined>;
-  getLogsStatsAggregate(organizationId: string, projectSecureId: string, query: AggregateQuery): Promise<AggregateResult>;
-  getLogsStatsDimensions(organizationId: string, projectSecureId: string, query: DimensionsQuery): Promise<DimensionsResult>;
-  getSourceUsage(organizationId: string, projectSecureId: string, query: SourceQuery): Promise<SourceResult>;
-}
-type DefenderContext = {
-  result?: {
-    riskLevel: string;
-    tier2Score?: number;
-    [key: string]: unknown;
-  };
-  [key: string]: unknown;
-};
-type ActionInput = {
-  actionRunId: string;
-  actionId?: string;
-  mode: string;
-  connectorKey: string;
-  connectorVersion: string;
-  connectorOwner?: string;
-  connectorProfileId?: string;
-  actionType: string;
-  category?: string;
-  organizationId: string;
-  projectSecureId: string;
-  accountSecureId: string;
-  originOwnerId?: string;
-  originOwnerName?: string;
-  authType?: AuthType;
-  authId?: string;
-  sourceType?: SourceType;
-  userAgent?: string;
-  ipAddress?: string;
-  sessionId?: string;
-  agentId?: string;
-  transportType?: TransportType;
-  streamType?: StreamType;
-  isBackground?: boolean;
-  pathParams?: unknown;
-  queryParams?: unknown;
-  body?: unknown;
-  headers?: Record<string, string>;
-  httpMethod?: string;
-  url?: string;
-  path?: string;
-  resource?: string;
-  subResource?: string;
-  childResource?: string;
-  startTime?: Date;
-};
-type ActionResult = {
-  success?: boolean;
-  statusCode?: number;
-  message?: string;
-  headers?: Record<string, string>;
-  body?: unknown;
-  defenderContext?: DefenderContext;
-  endTime?: Date;
-};
-type StepInput = {
-  actionRunId: string;
-  actionMode: string;
-  actionSuccess?: boolean;
-  stepIndex: number;
-  stepId: string;
-  stepFunctionName?: string;
-  stepFunctionVersion?: string;
-  stepIterations?: number;
-  organizationId: string;
-  projectSecureId: string;
-  accountSecureId: string;
-  inputs?: {
-    [key: string]: unknown;
-  };
-  startTime?: Date;
-};
-type StepResult = {
-  success?: boolean;
-  statusCode?: number;
-  message?: string;
-  outputs?: unknown;
-  errors?: unknown;
-  skipped?: boolean;
-  endTime?: Date;
-};
-type UnifiedInput = {
-  requestId: string;
-  organizationId: string;
-  projectSecureId: string;
-  accountSecureId: string;
-  originOwnerId?: string;
-  originOwnerName?: string;
-  connectorKey: string;
-  action?: string;
-  service?: string;
-  mode?: string;
-  httpMethod?: string;
-  url?: string;
-  path?: string;
-  queryParams?: unknown;
-  body?: unknown;
-  headers?: Record<string, string>;
-  resource?: string;
-  subResource?: string;
-  childResource?: string;
-  authType?: AuthType;
-  authId?: string;
-  sourceType?: SourceType;
-  userAgent?: string;
-  ipAddress?: string;
-  transportType?: TransportType;
-  isBackground?: boolean;
-  startTime?: Date;
-};
-type UnifiedResult = {
-  success?: boolean;
-  statusCode?: number;
-  message?: string;
-  headers?: Record<string, string>;
-  body?: unknown;
-  endTime?: Date;
-};
-type ProviderInput = {
-  requestId: string;
-  id: string;
-  organizationId: string;
-  projectSecureId: string;
-  accountSecureId: string;
-  originOwnerId?: string;
-  originOwnerName?: string;
-  connectorKey: string;
-  action: string;
-  service: string;
-  mode: string;
-  httpMethod: string;
-  url: string;
-  path?: string;
-  queryParams?: unknown;
-  headers?: Record<string, string>;
-  body?: unknown;
-  resource?: string;
-  subResource?: string;
-  childResource?: string;
-  startTime?: Date;
-};
-type ProviderResult = {
-  success?: boolean;
-  statusCode?: number;
-  headers?: Record<string, string>;
-  body?: unknown;
-  errors?: unknown;
-  endTime?: Date;
-};
-//#endregion
-//#region ../olap/src/logs/types.d.ts
-declare const LogType: {
-  readonly Action: "action";
-  readonly Step: "step";
-  readonly Unified: "unified";
-  readonly Provider: "provider";
-};
-type LogType = (typeof LogType)[keyof typeof LogType];
-type Query = {
-  organizationId?: string | string[];
-  projectSecureId?: string | string[];
-  actionRunId?: string | string[];
-  accountSecureId?: string | string[];
-  actionId?: string | string[];
-  connectorKey?: string | string[];
-  mode?: string | string[];
-  category?: string | string[];
-  requestId?: string | string[];
-  provider?: string | string[];
-  service?: string | string[];
-  resource?: string | string[];
-  subResource?: string | string[];
-  childResource?: string | string[];
-  action?: string | string[];
-  statusCode?: string | string[];
-  sourceId?: string | string[];
-  sourceType?: string | string[];
-  sourceValue?: string | string[];
-  originOwnerId?: string | string[];
-  httpMethod?: string | string[];
-  isBackground?: boolean;
-  logId?: string | string[];
-  logType?: (typeof LogType.Action | typeof LogType.Unified) | (typeof LogType.Action | typeof LogType.Unified)[];
-  success?: boolean;
-  startTime?: Date;
-  endTime?: Date;
-  pageNumber?: number;
-  pageSize?: number;
-};
-type QueryResult = {
-  logs: Array<ActionLog | UnifiedLog | StepLog | ProviderLog>;
-  total: number;
-  pageNumber: number;
-  pageSize: number;
-};
-type ActionsQuery = {
-  organizationId?: string | string[];
-  projectSecureId?: string | string[];
-  actionRunId?: string | string[];
-  accountSecureId?: string | string[];
-  actionId?: string | string[];
-  connectorKey?: string | string[];
-  mode?: string | string[];
-  category?: string | string[];
-  isBackground?: boolean;
-  success?: boolean;
-  startTime?: Date;
-  endTime?: Date;
-  pageNumber?: number;
-  pageSize?: number;
-};
-type ActionsQueryResult = {
-  actionLogs: ActionLog[];
-  total: number;
-  pageNumber: number;
-  pageSize: number;
-};
-type StepsQuery = {
-  organizationId?: string | string[];
-  projectSecureId?: string | string[];
-  accountSecureId?: string | string[];
-  actionRunId?: string | string[];
-  stepId?: string | string[];
-  stepIndex?: number | number[];
-  success?: boolean;
-  startTime?: Date;
-  endTime?: Date;
-  pageNumber?: number;
-  pageSize?: number;
-};
-type StepsQueryResult = {
-  stepLogs: StepLog[];
-  total: number;
-  pageNumber: number;
-  pageSize: number;
-};
-type UnifiedQuery = {
-  organizationId?: string | string[];
-  projectSecureId?: string | string[];
-  accountSecureId?: string | string[];
-  requestId?: string | string[];
-  connectorKey?: string | string[];
-  resource?: string | string[];
-  source?: string | string[];
-  category?: string | string[];
-  originOwnerId?: string | string[];
-  isBackground?: boolean;
-  success?: boolean;
-  startTime?: Date;
-  endTime?: Date;
-  pageNumber?: number;
-  pageSize?: number;
-};
-type UnifiedQueryResult = {
-  unifiedLogs: UnifiedLog[];
-  total: number;
-  pageNumber: number;
-  pageSize: number;
-};
-type ProviderQuery = {
-  organizationId?: string | string[];
-  projectSecureId?: string | string[];
-  accountSecureId?: string | string[];
-  requestId?: string | string[];
-  id?: string | string[];
-  success?: boolean;
-  startTime?: Date;
-  endTime?: Date;
-  pageNumber?: number;
-  pageSize?: number;
-};
-type ProviderQueryResult = {
-  providerLogs: ProviderLog[];
-  total: number;
-  pageNumber: number;
-  pageSize: number;
-};
-type IntervalType = 'minute' | 'hour' | 'day' | 'week' | 'month';
-declare const Dimension: {
-  readonly ConnectorKey: "connector_key";
-  readonly Success: "success";
-  readonly ActionType: "action_type";
-  readonly Mode: "mode";
-  readonly Service: "service";
-  readonly Resource: "resource";
-  readonly ActionId: "action_id";
-  readonly HttpMethod: "http_method";
-  readonly AccountSecureId: "account_secure_id";
-  readonly SourceType: "source_type";
-  readonly StatusCode: "status_code";
-  readonly OriginOwnerId: "origin_owner_id";
-  readonly SourceId: "source_id";
-  readonly IsBackground: "is_background";
-};
-type Dimension = (typeof Dimension)[keyof typeof Dimension];
-type AggregateQuery = Partial<Query> & {
-  dimensions?: Dimension[];
-  intervalType?: IntervalType;
-  intervalPeriod?: number;
-};
-type AggregateResult = {
-  data: Array<{
-    start_time?: string;
-    count: number;
-    [dimension: string]: unknown;
-  }>;
-};
-type DimensionsQuery = Partial<Query> & {
-  dimensions: Dimension[];
-  maxValues?: number;
-};
-type DimensionsResult = {
-  [dimension: string]: Array<{
-    value: string;
-    count: number;
-  }>;
-};
-type SourceQuery = Partial<Query>;
-type SourceResult = Array<{
-  sourceId: string;
-  sourceType: string;
-  requestCount: number;
-  lastRequest: string;
-}>;
-interface ILog {
-  logType: LogType;
-  eventTime: Date;
-  startTime: Date;
-  endTime?: Date;
-  durationMs?: number;
-  organizationId: string;
-  projectSecureId?: string;
-  accountSecureId?: string;
-}
-type ActionLog = ILog & {
-  logType: typeof LogType.Action;
-  actionRunId: string;
-  actionId: string;
-  connectorKey: string;
-  connectorVersion: string;
-  connectorOwner?: string;
-  connectorProfileId?: string;
-  organizationId: string;
-  projectSecureId: string;
-  accountSecureId: string;
-  actionType?: string;
-  mode?: string;
-  category?: string;
-  originOwnerId?: string;
-  originOwnerName?: string;
-  httpMethod?: string;
-  url?: string;
-  sourceType?: SourceType;
-  sourceId?: string;
-  sourceValue?: string;
-  authType?: AuthType;
-  authId?: string;
-  userAgent?: string;
-  ipAddress?: string;
-  sessionId?: string;
-  agentId?: string;
-  transportType?: TransportType;
-  streamType?: StreamType;
-  isBackground?: boolean;
-  success?: boolean;
-  statusCode?: number;
-  riskLevel?: string;
-  tier2Score?: number;
-  advancedExpiresAt?: Date;
-  defenderExpiresAt?: Date;
-};
-type StepLog = ILog & {
-  logType: typeof LogType.Step;
-  actionRunId: string;
-  stepIndex: number;
-  stepId: string;
-  stepFunctionName?: string;
-  stepFunctionVersion?: string;
-  stepIterations?: number;
-  organizationId: string;
-  projectSecureId: string;
-  accountSecureId: string;
-  skipped?: boolean;
-  success?: boolean;
-  statusCode?: number;
-  message?: string;
-};
-type UnifiedLog = ILog & {
-  logType: typeof LogType.Unified;
-  requestId: string;
-  organizationId: string;
-  projectSecureId: string;
-  accountSecureId: string;
-  connectorKey: string;
-  connectorVersion?: string;
-  mode?: string;
-  httpMethod?: string;
-  url?: string;
-  path?: string;
-  resource?: string;
-  subResource?: string;
-  childResource?: string;
-  service?: string;
-  action?: string;
-  sourceId?: string;
-  sourceType?: SourceType;
-  sourceValue?: string;
-  authType?: AuthType;
-  authId?: string;
-  userAgent?: string;
-  ipAddress?: string;
-  sessionId?: string;
-  agentId?: string;
-  transportType?: TransportType;
-  streamType?: StreamType;
-  isBackground?: boolean;
-  originOwnerId?: string;
-  originOwnerName?: string;
-  statusCode?: number;
-  success?: boolean;
-  isWorker?: boolean;
-  status?: number;
-  provider?: string;
-  eventDatetime?: Date;
-  duration?: number;
-  advancedExpiresAt?: Date;
-};
-type ProviderLog = ILog & {
-  logType: typeof LogType.Provider;
-  requestId: string;
-  id?: string;
-  organizationId: string;
-  projectSecureId: string;
-  accountSecureId: string;
-  connectorKey: string;
-  connectorVersion?: string;
-  action: string;
-  mode?: string;
-  httpMethod: string;
-  originOwnerId?: string;
-  originOwnerName?: string;
-  url: string;
-  path?: string;
-  resource?: string;
-  subResource?: string;
-  childResource?: string;
-  service?: string;
-  success?: boolean;
-  statusCode?: number;
-  isWorker?: boolean;
-  status?: number;
-  provider?: string;
-  eventDatetime?: Date;
-  duration?: number;
-};
-//#endregion
 //#region src/categories/types.d.ts
 type Category = 'hris' | 'crm' | 'ats' | 'lms' | 'marketing' | 'filestorage' | 'iam' | 'internal' | 'action';
 type CategoryDetails = {
@@ -961,6 +190,9 @@ interface TimeFilterIncrementalConfig extends BaseIncrementalConfig {
   safetyBufferSeconds?: number;
 }
 //#endregion
+//#region src/incrementalSync/incrementalUtils.d.ts
+declare function stripIncrementalParams(params: SyncParams, config: BaseIncrementalConfig | undefined): SyncParams;
+//#endregion
 //#region src/incrementalSync/checkpoint.d.ts
 type Checkpoint = {
   kind: 'timestamp';
@@ -991,6 +223,1513 @@ type SchemaField = {
   description?: string;
 };
 //#endregion
+//#region ../../node_modules/zod/v4/core/standard-schema.d.cts
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//#endregion
+//#region ../../node_modules/zod/v4/core/util.d.cts
+type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type MakePartial<T, K extends keyof T> = Omit$1<T, K> & InexactPartial<Pick<T, K>>;
+type NoUndefined<T> = T extends undefined ? never : T;
+type Whatever = {} | undefined | null;
+type LoosePartial<T extends object> = InexactPartial<T> & {
+  [k: string]: unknown;
+};
+type Mask<Keys extends PropertyKey> = { [K in Keys]?: true };
+type InexactPartial<T> = { [P in keyof T]?: T[P] | undefined };
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+  readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+type SomeObject = Record<PropertyKey, any>;
+type Identity<T> = T;
+type Flatten<T> = Identity<{ [k in keyof T]: T[k] }>;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K] } & { [K in keyof B]: B[K] }>;
+type AnyFunc = (...args: any[]) => any;
+type MaybeAsync<T> = T | Promise<T>;
+type EnumValue = string | number;
+type EnumLike = Readonly<Record<string, EnumValue>>;
+type ToEnum<T extends EnumValue> = Flatten<{ [k in T]: k }>;
+type Literal = string | number | bigint | boolean | null | undefined;
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type HasLength = {
+  length: number;
+};
+type Numeric = number | bigint | Date;
+type PropValues = Record<string, Set<Primitive>>;
+type PrimitiveSet = Set<Primitive>;
+type EmptyToNever<T> = keyof T extends never ? never : T;
+declare abstract class Class {
+  constructor(..._args: any[]);
+}
+//#endregion
+//#region ../../node_modules/zod/v4/core/versions.d.cts
+declare const version$1: {
+  readonly major: 4;
+  readonly minor: 0;
+  readonly patch: number;
+};
+//#endregion
+//#region ../../node_modules/zod/v4/core/schemas.d.cts
+interface ParseContext<T extends $ZodIssueBase = never> {
+  /** Customize error messages. */
+  readonly error?: $ZodErrorMap<T>;
+  /** Include the `input` field in issue objects. Default `false`. */
+  readonly reportInput?: boolean;
+  /** Skip eval-based fast path. Default `false`. */
+  readonly jitless?: boolean;
+}
+/** @internal */
+interface ParseContextInternal<T extends $ZodIssueBase = never> extends ParseContext<T> {
+  readonly async?: boolean | undefined;
+}
+interface ParsePayload<T = unknown> {
+  value: T;
+  issues: $ZodRawIssue[];
+}
+type CheckFn<T> = (input: ParsePayload<T>) => MaybeAsync<void>;
+interface $ZodTypeDef {
+  type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "custom";
+  error?: $ZodErrorMap<never> | undefined;
+  checks?: $ZodCheck<never>[];
+}
+interface _$ZodTypeInternals {
+  /** The `@zod/core` version of this schema */
+  version: typeof version$1;
+  /** Schema definition. */
+  def: $ZodTypeDef;
+  /** @internal Randomly generated ID for this schema. */
+  /** @internal List of deferred initializers. */
+  deferred: AnyFunc[] | undefined;
+  /** @internal Parses input and runs all checks (refinements). */
+  run(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
+  /** @internal Parses input, doesn't run checks. */
+  parse(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
+  /** @internal  Stores identifiers for the set of traits implemented by this schema. */
+  traits: Set<string>;
+  /** @internal Indicates that a schema output type should be considered optional inside objects.
+   * @default Required
+   */
+  /** @internal */
+  optin?: "optional" | undefined;
+  /** @internal */
+  optout?: "optional" | undefined;
+  /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
+   *
+   * Defined on: enum, const, literal, null, undefined
+   * Passthrough: optional, nullable, branded, default, catch, pipe
+   * Todo: unions?
+   */
+  values?: PrimitiveSet | undefined;
+  /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
+  propValues?: PropValues | undefined;
+  /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
+  pattern: RegExp | undefined;
+  /** @internal The constructor function of this schema. */
+  constr: new (def: any) => $ZodType;
+  /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
+  bag: Record<string, unknown>;
+  /** @internal The set of issues this schema might throw during type checking. */
+  isst: $ZodIssueBase;
+  /** An optional method used to override `toJSONSchema` logic. */
+  toJSONSchema?: () => unknown;
+  /** @internal The parent of this schema. Only set during certain clone operations. */
+  parent?: $ZodType | undefined;
+}
+/** @internal */
+interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
+  /** @internal The inferred output type */
+  output: O;
+  /** @internal The inferred input type */
+  input: I;
+}
+type $ZodStandardSchema<T> = StandardSchemaV1.Props<input<T>, output<T>>;
+type SomeType = {
+  _zod: _$ZodTypeInternals;
+};
+interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
+  _zod: Internals;
+  "~standard": $ZodStandardSchema<this>;
+}
+declare const $ZodType: $constructor<$ZodType>;
+interface $ZodStringDef extends $ZodTypeDef {
+  type: "string";
+  coerce?: boolean;
+  checks?: $ZodCheck<string>[];
+}
+interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
+  def: $ZodStringDef;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    patterns: Set<RegExp>;
+    format: string;
+    contentEncoding: string;
+  }>;
+}
+interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {}
+interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
+  def: $ZodStringFormatDef<Format>;
+}
+interface $ZodStringFormat<Format extends string = string> extends $ZodType {
+  _zod: $ZodStringFormatInternals<Format>;
+}
+declare const $ZodStringFormat: $constructor<$ZodStringFormat>;
+interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {}
+interface $ZodGUID extends $ZodType {
+  _zod: $ZodGUIDInternals;
+}
+declare const $ZodGUID: $constructor<$ZodGUID>;
+interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
+  version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
+}
+interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
+  def: $ZodUUIDDef;
+}
+interface $ZodUUID extends $ZodType {
+  _zod: $ZodUUIDInternals;
+}
+declare const $ZodUUID: $constructor<$ZodUUID>;
+interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {}
+interface $ZodEmail extends $ZodType {
+  _zod: $ZodEmailInternals;
+}
+declare const $ZodEmail: $constructor<$ZodEmail>;
+interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
+  hostname?: RegExp | undefined;
+  protocol?: RegExp | undefined;
+}
+interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
+  def: $ZodURLDef;
+}
+interface $ZodURL extends $ZodType {
+  _zod: $ZodURLInternals;
+}
+declare const $ZodURL: $constructor<$ZodURL>;
+interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {}
+interface $ZodEmoji extends $ZodType {
+  _zod: $ZodEmojiInternals;
+}
+declare const $ZodEmoji: $constructor<$ZodEmoji>;
+interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {}
+interface $ZodNanoID extends $ZodType {
+  _zod: $ZodNanoIDInternals;
+}
+declare const $ZodNanoID: $constructor<$ZodNanoID>;
+interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {}
+interface $ZodCUID extends $ZodType {
+  _zod: $ZodCUIDInternals;
+}
+declare const $ZodCUID: $constructor<$ZodCUID>;
+interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {}
+interface $ZodCUID2 extends $ZodType {
+  _zod: $ZodCUID2Internals;
+}
+declare const $ZodCUID2: $constructor<$ZodCUID2>;
+interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {}
+interface $ZodULID extends $ZodType {
+  _zod: $ZodULIDInternals;
+}
+declare const $ZodULID: $constructor<$ZodULID>;
+interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {}
+interface $ZodXID extends $ZodType {
+  _zod: $ZodXIDInternals;
+}
+declare const $ZodXID: $constructor<$ZodXID>;
+interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {}
+interface $ZodKSUID extends $ZodType {
+  _zod: $ZodKSUIDInternals;
+}
+declare const $ZodKSUID: $constructor<$ZodKSUID>;
+interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
+  precision: number | null;
+  offset: boolean;
+  local: boolean;
+}
+interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
+  def: $ZodISODateTimeDef;
+}
+interface $ZodISODateTime extends $ZodType {
+  _zod: $ZodISODateTimeInternals;
+}
+declare const $ZodISODateTime: $constructor<$ZodISODateTime>;
+interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {}
+interface $ZodISODate extends $ZodType {
+  _zod: $ZodISODateInternals;
+}
+declare const $ZodISODate: $constructor<$ZodISODate>;
+interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
+  precision?: number | null;
+}
+interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
+  def: $ZodISOTimeDef;
+}
+interface $ZodISOTime extends $ZodType {
+  _zod: $ZodISOTimeInternals;
+}
+declare const $ZodISOTime: $constructor<$ZodISOTime>;
+interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {}
+interface $ZodISODuration extends $ZodType {
+  _zod: $ZodISODurationInternals;
+}
+declare const $ZodISODuration: $constructor<$ZodISODuration>;
+interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
+  version?: "v4";
+}
+interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
+  def: $ZodIPv4Def;
+}
+interface $ZodIPv4 extends $ZodType {
+  _zod: $ZodIPv4Internals;
+}
+declare const $ZodIPv4: $constructor<$ZodIPv4>;
+interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
+  version?: "v6";
+}
+interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
+  def: $ZodIPv6Def;
+}
+interface $ZodIPv6 extends $ZodType {
+  _zod: $ZodIPv6Internals;
+}
+declare const $ZodIPv6: $constructor<$ZodIPv6>;
+interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
+  version?: "v4";
+}
+interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
+  def: $ZodCIDRv4Def;
+}
+interface $ZodCIDRv4 extends $ZodType {
+  _zod: $ZodCIDRv4Internals;
+}
+declare const $ZodCIDRv4: $constructor<$ZodCIDRv4>;
+interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
+  version?: "v6";
+}
+interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
+  def: $ZodCIDRv6Def;
+}
+interface $ZodCIDRv6 extends $ZodType {
+  _zod: $ZodCIDRv6Internals;
+}
+declare const $ZodCIDRv6: $constructor<$ZodCIDRv6>;
+interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {}
+interface $ZodBase64 extends $ZodType {
+  _zod: $ZodBase64Internals;
+}
+declare const $ZodBase64: $constructor<$ZodBase64>;
+interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {}
+interface $ZodBase64URL extends $ZodType {
+  _zod: $ZodBase64URLInternals;
+}
+declare const $ZodBase64URL: $constructor<$ZodBase64URL>;
+interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {}
+interface $ZodE164 extends $ZodType {
+  _zod: $ZodE164Internals;
+}
+declare const $ZodE164: $constructor<$ZodE164>;
+interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
+  alg?: JWTAlgorithm | undefined;
+}
+interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
+  def: $ZodJWTDef;
+}
+interface $ZodJWT extends $ZodType {
+  _zod: $ZodJWTInternals;
+}
+declare const $ZodJWT: $constructor<$ZodJWT>;
+interface $ZodNumberDef extends $ZodTypeDef {
+  type: "number";
+  coerce?: boolean;
+}
+interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number, Input> {
+  def: $ZodNumberDef;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    exclusiveMinimum: number;
+    exclusiveMaximum: number;
+    format: string;
+    pattern: RegExp;
+  }>;
+}
+interface $ZodBooleanDef extends $ZodTypeDef {
+  type: "boolean";
+  coerce?: boolean;
+  checks?: $ZodCheck<boolean>[];
+}
+interface $ZodBooleanInternals<T = unknown> extends $ZodTypeInternals<boolean, T> {
+  pattern: RegExp;
+  def: $ZodBooleanDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodUnknownDef extends $ZodTypeDef {
+  type: "unknown";
+}
+interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
+  def: $ZodUnknownDef;
+  isst: never;
+}
+interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "array";
+  element: T;
+}
+interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$ZodTypeInternals {
+  def: $ZodArrayDef<T>;
+  isst: $ZodIssueInvalidType;
+  output: output<T>[];
+  input: input<T>[];
+}
+interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {}
+declare const $ZodArray: $constructor<$ZodArray>;
+type OptionalOutSchema = {
+  _zod: {
+    optout: "optional";
+  };
+};
+type OptionalInSchema = {
+  _zod: {
+    optin: "optional";
+  };
+};
+type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, output<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"] } & { -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"] } & Extra>;
+type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, input<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"] } & { -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"] } & Extra>;
+type $ZodObjectConfig = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $loose = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $strict = {
+  out: {};
+  in: {};
+};
+type $strip = {
+  out: {};
+  in: {};
+};
+type $catchall<T extends SomeType> = {
+  out: {
+    [k: string]: output<T>;
+  };
+  in: {
+    [k: string]: input<T>;
+  };
+};
+type $ZodShape = Readonly<{
+  [k: string]: $ZodType;
+}>;
+interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
+  type: "object";
+  shape: Shape;
+  catchall?: $ZodType | undefined;
+}
+interface $ZodObjectInternals< /** @ts-ignore Cast variance */out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
+  def: $ZodObjectDef<Shape>;
+  config: Config;
+  isst: $ZodIssueInvalidType | $ZodIssueUnrecognizedKeys;
+  propValues: PropValues;
+  output: $InferObjectOutput<Shape, Config["out"]>;
+  input: $InferObjectInput<Shape, Config["in"]>;
+}
+type $ZodLooseShape = Record<string, any>;
+interface $ZodObject< /** @ts-ignore Cast variance */out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
+  "~standard": $ZodStandardSchema<this>;
+}
+declare const $ZodObject: $constructor<$ZodObject>;
+type $InferUnionOutput<T extends SomeType> = T extends any ? output<T> : never;
+type $InferUnionInput<T extends SomeType> = T extends any ? input<T> : never;
+interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
+  type: "union";
+  options: Options;
+}
+type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
+type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
+interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
+  def: $ZodUnionDef<T>;
+  isst: $ZodIssueInvalidUnion;
+  pattern: T[number]["_zod"]["pattern"];
+  values: T[number]["_zod"]["values"];
+  output: $InferUnionOutput<T[number]>;
+  input: $InferUnionInput<T[number]>;
+  optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
+  optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
+}
+interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T>> {
+  _zod: $ZodUnionInternals<T>;
+}
+declare const $ZodUnion: $constructor<$ZodUnion>;
+interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionDef<Options> {
+  discriminator: string;
+  unionFallback?: boolean;
+}
+interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<Options> {
+  def: $ZodDiscriminatedUnionDef<Options>;
+  propValues: PropValues;
+}
+interface $ZodDiscriminatedUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
+  _zod: $ZodDiscriminatedUnionInternals<T>;
+}
+declare const $ZodDiscriminatedUnion: $constructor<$ZodDiscriminatedUnion>;
+interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "intersection";
+  left: Left;
+  right: Right;
+}
+interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<A> & output<B>, input<A> & input<B>> {
+  def: $ZodIntersectionDef<A, B>;
+  isst: never;
+  optin: A["_zod"]["optin"] | B["_zod"]["optin"];
+  optout: A["_zod"]["optout"] | B["_zod"]["optout"];
+}
+interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodIntersectionInternals<A, B>;
+}
+declare const $ZodIntersection: $constructor<$ZodIntersection>;
+type $ZodRecordKey = $ZodType<string | number | symbol, string | number | symbol>;
+interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "record";
+  keyType: Key;
+  valueType: Value;
+}
+type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output<Key>, output<Value>>> : Record<output<Key>, output<Value>>;
+type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input<Key>, input<Value>>> : Record<input<Key>, input<Value>>;
+interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
+  def: $ZodRecordDef<Key, Value>;
+  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $partial = {
+  "~~partial": true;
+};
+interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodRecordInternals<Key, Value>;
+}
+declare const $ZodRecord: $constructor<$ZodRecord>;
+type $InferEnumOutput<T extends EnumLike> = T[keyof T] & {};
+type $InferEnumInput<T extends EnumLike> = T[keyof T] & {};
+interface $ZodEnumDef<T extends EnumLike = EnumLike> extends $ZodTypeDef {
+  type: "enum";
+  entries: T;
+}
+interface $ZodEnumInternals< /** @ts-ignore Cast variance */out T extends EnumLike = EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T>, $InferEnumInput<T>> {
+  def: $ZodEnumDef<T>;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  values: PrimitiveSet;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodEnum<T extends EnumLike = EnumLike> extends $ZodType {
+  _zod: $ZodEnumInternals<T>;
+}
+declare const $ZodEnum: $constructor<$ZodEnum>;
+interface $ZodLiteralDef<T extends Literal> extends $ZodTypeDef {
+  type: "literal";
+  values: T[];
+}
+interface $ZodLiteralInternals<T extends Literal = Literal> extends $ZodTypeInternals<T, T> {
+  def: $ZodLiteralDef<T>;
+  values: Set<T>;
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodLiteral<T extends Literal = Literal> extends $ZodType {
+  _zod: $ZodLiteralInternals<T>;
+}
+declare const $ZodLiteral: $constructor<$ZodLiteral>;
+declare global {
+  interface File {}
+}
+interface $ZodTransformDef extends $ZodTypeDef {
+  type: "transform";
+  transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
+}
+interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
+  def: $ZodTransformDef;
+  isst: never;
+}
+interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodTransformInternals<O, I>;
+}
+declare const $ZodTransform: $constructor<$ZodTransform>;
+interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "optional";
+  innerType: T;
+}
+interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | undefined, input<T> | undefined> {
+  def: $ZodOptionalDef<T>;
+  optin: "optional";
+  optout: "optional";
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodOptionalInternals<T>;
+}
+declare const $ZodOptional: $constructor<$ZodOptional>;
+interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nullable";
+  innerType: T;
+}
+interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | null, input<T> | null> {
+  def: $ZodNullableDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNullableInternals<T>;
+}
+declare const $ZodNullable: $constructor<$ZodNullable>;
+interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "default";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: NoUndefined<output<T>>;
+}
+interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+  def: $ZodDefaultDef<T>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodDefaultInternals<T>;
+}
+declare const $ZodDefault: $constructor<$ZodDefault>;
+interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "prefault";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: input<T>;
+}
+interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+  def: $ZodPrefaultDef<T>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPrefaultInternals<T>;
+}
+declare const $ZodPrefault: $constructor<$ZodPrefault>;
+interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nonoptional";
+  innerType: T;
+}
+interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, NoUndefined<input<T>>> {
+  def: $ZodNonOptionalDef<T>;
+  isst: $ZodIssueInvalidType;
+  values: T["_zod"]["values"];
+  optin: "optional" | undefined;
+  optout: "optional" | undefined;
+}
+interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNonOptionalInternals<T>;
+}
+declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
+interface $ZodCatchCtx extends ParsePayload {
+  /** @deprecated Use `ctx.issues` */
+  error: {
+    issues: $ZodIssue[];
+  };
+  /** @deprecated Use `ctx.value` */
+  input: unknown;
+}
+interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "catch";
+  innerType: T;
+  catchValue: (ctx: $ZodCatchCtx) => unknown;
+}
+interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T> | Whatever> {
+  def: $ZodCatchDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodCatchInternals<T>;
+}
+declare const $ZodCatch: $constructor<$ZodCatch>;
+interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "pipe";
+  in: A;
+  out: B;
+}
+interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
+  def: $ZodPipeDef<A, B>;
+  isst: never;
+  values: A["_zod"]["values"];
+  optin: A["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+}
+interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPipeInternals<A, B>;
+}
+declare const $ZodPipe: $constructor<$ZodPipe>;
+interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "readonly";
+  innerType: T;
+}
+interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T>>, MakeReadonly<input<T>>> {
+  def: $ZodReadonlyDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  propValues: T["_zod"]["propValues"];
+  values: T["_zod"]["values"];
+}
+interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodReadonlyInternals<T>;
+}
+declare const $ZodReadonly: $constructor<$ZodReadonly>;
+interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "lazy";
+  getter: () => T;
+}
+interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+  def: $ZodLazyDef<T>;
+  isst: never;
+  /** Auto-cached way to retrieve the inner schema */
+  innerType: T;
+  pattern: T["_zod"]["pattern"];
+  propValues: T["_zod"]["propValues"];
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+}
+interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodLazyInternals<T>;
+}
+declare const $ZodLazy: $constructor<$ZodLazy>;
+interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, $ZodCheckDef {
+  type: "custom";
+  check: "custom";
+  path?: PropertyKey[] | undefined;
+  error?: $ZodErrorMap | undefined;
+  params?: Record<string, any> | undefined;
+  fn: (arg: O) => unknown;
+}
+interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, $ZodCheckInternals<O> {
+  def: $ZodCustomDef;
+  issc: $ZodIssue;
+  isst: never;
+  bag: LoosePartial<{
+    Class: typeof Class;
+  }>;
+}
+interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodCustomInternals<O, I>;
+}
+declare const $ZodCustom: $constructor<$ZodCustom>;
+//#endregion
+//#region ../../node_modules/zod/v4/core/checks.d.cts
+interface $ZodCheckDef {
+  check: string;
+  error?: $ZodErrorMap<never> | undefined;
+  /** If true, no later checks will be executed if this check fails. Default `false`. */
+  abort?: boolean | undefined;
+  /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
+  when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+interface $ZodCheckInternals<T> {
+  def: $ZodCheckDef;
+  /** The set of issues this check might throw. */
+  issc?: $ZodIssueBase;
+  check(payload: ParsePayload<T>): MaybeAsync<void>;
+  onattach: ((schema: $ZodType) => void)[];
+}
+interface $ZodCheck<in T = never> {
+  _zod: $ZodCheckInternals<T>;
+}
+declare const $ZodCheck: $constructor<$ZodCheck<any>>;
+interface $ZodCheckLessThanDef extends $ZodCheckDef {
+  check: "less_than";
+  value: Numeric;
+  inclusive: boolean;
+}
+interface $ZodCheckLessThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLessThanDef;
+  issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckLessThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+  _zod: $ZodCheckLessThanInternals<T>;
+}
+declare const $ZodCheckLessThan: $constructor<$ZodCheckLessThan>;
+interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
+  check: "greater_than";
+  value: Numeric;
+  inclusive: boolean;
+}
+interface $ZodCheckGreaterThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+  def: $ZodCheckGreaterThanDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckGreaterThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+  _zod: $ZodCheckGreaterThanInternals<T>;
+}
+declare const $ZodCheckGreaterThan: $constructor<$ZodCheckGreaterThan>;
+interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
+  check: "multiple_of";
+  value: T;
+}
+interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMultipleOfDef<T>;
+  issc: $ZodIssueNotMultipleOf;
+}
+interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
+  _zod: $ZodCheckMultipleOfInternals<T>;
+}
+declare const $ZodCheckMultipleOf: $constructor<$ZodCheckMultipleOf<number | bigint>>;
+type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
+interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
+  check: "number_format";
+  format: $ZodNumberFormats;
+}
+interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
+  def: $ZodCheckNumberFormatDef;
+  issc: $ZodIssueInvalidType | $ZodIssueTooBig<"number"> | $ZodIssueTooSmall<"number">;
+}
+interface $ZodCheckNumberFormat extends $ZodCheck<number> {
+  _zod: $ZodCheckNumberFormatInternals;
+}
+declare const $ZodCheckNumberFormat: $constructor<$ZodCheckNumberFormat>;
+interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
+  check: "max_length";
+  maximum: number;
+}
+interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMaxLengthDef;
+  issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMaxLengthInternals<T>;
+}
+declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
+interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+  check: "min_length";
+  minimum: number;
+}
+interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMinLengthDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMinLengthInternals<T>;
+}
+declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
+interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+  check: "length_equals";
+  length: number;
+}
+interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLengthEqualsDef;
+  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
+type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
+  check: "string_format";
+  format: Format;
+  pattern?: RegExp | undefined;
+}
+interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStringFormatDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
+  format: "regex";
+  pattern: RegExp;
+}
+interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckRegexDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegex extends $ZodCheck<string> {
+  _zod: $ZodCheckRegexInternals;
+}
+declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
+interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {}
+interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckLowerCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckLowerCase extends $ZodCheck<string> {
+  _zod: $ZodCheckLowerCaseInternals;
+}
+declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
+interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {}
+interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckUpperCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckUpperCase extends $ZodCheck<string> {
+  _zod: $ZodCheckUpperCaseInternals;
+}
+declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
+interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
+  includes: string;
+  position?: number | undefined;
+}
+interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckIncludesDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckIncludes extends $ZodCheck<string> {
+  _zod: $ZodCheckIncludesInternals;
+}
+declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
+interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
+  prefix: string;
+}
+interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStartsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckStartsWith extends $ZodCheck<string> {
+  _zod: $ZodCheckStartsWithInternals;
+}
+declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
+interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
+  suffix: string;
+}
+interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckEndsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
+  _zod: $ZodCheckEndsWithInternals;
+}
+declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
+//#endregion
+//#region ../../node_modules/zod/v4/core/errors.d.cts
+interface $ZodIssueBase {
+  readonly code?: string;
+  readonly input?: unknown;
+  readonly path: PropertyKey[];
+  readonly message: string;
+}
+interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_type";
+  readonly expected: $ZodType["_zod"]["def"]["type"];
+  readonly input: Input;
+}
+interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
+  readonly code: "too_big";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly maximum: number | bigint;
+  readonly inclusive?: boolean;
+  readonly exact?: boolean;
+  readonly input: Input;
+}
+interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
+  readonly code: "too_small";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly minimum: number | bigint;
+  /** True if the allowable range includes the minimum */
+  readonly inclusive?: boolean;
+  /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
+  readonly exact?: boolean;
+  readonly input: Input;
+}
+interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
+  readonly code: "invalid_format";
+  readonly format: $ZodStringFormats | (string & {});
+  readonly pattern?: string;
+  readonly input: string;
+}
+interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
+  readonly code: "not_multiple_of";
+  readonly divisor: number;
+  readonly input: Input;
+}
+interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
+  readonly code: "unrecognized_keys";
+  readonly keys: string[];
+  readonly input: Record<string, unknown>;
+}
+interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: $ZodIssue[][];
+  readonly input: unknown;
+}
+interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_key";
+  readonly origin: "map" | "record";
+  readonly issues: $ZodIssue[];
+  readonly input: Input;
+}
+interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_element";
+  readonly origin: "map" | "set";
+  readonly key: unknown;
+  readonly issues: $ZodIssue[];
+  readonly input: Input;
+}
+interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_value";
+  readonly values: Primitive[];
+  readonly input: Input;
+}
+interface $ZodIssueCustom extends $ZodIssueBase {
+  readonly code: "custom";
+  readonly params?: Record<string, any> | undefined;
+  readonly input: unknown;
+}
+type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = Flatten<MakePartial<T, "message" | "path"> & {
+  /** The input data */readonly input?: unknown; /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck; /** @deprecated Internal use only. If `true`, Zod will continue executing validation despite this issue. */
+  readonly continue?: boolean | undefined;
+} & Record<string, any>>;
+interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
+  (issue: $ZodRawIssue<T>): {
+    message: string;
+  } | string | undefined | null;
+}
+interface $ZodError<T = unknown> extends Error {
+  type: T;
+  issues: $ZodIssue[];
+  _zod: {
+    output: T;
+    def: $ZodIssue[];
+  };
+  stack?: string;
+  name: string;
+}
+declare const $ZodError: $constructor<$ZodError>;
+type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in keyof T]?: U[] };
+};
+type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? { [K in keyof T]?: $ZodFormattedError<T[K], U> } : T extends any[] ? {
+  [k: number]: $ZodFormattedError<T[number], U>;
+} : T extends object ? Flatten<{ [K in keyof T]?: $ZodFormattedError<T[K], U> }> : any;
+type $ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & Flatten<_ZodFormattedError<T, U>>;
+//#endregion
+//#region ../../node_modules/zod/v4/core/core.d.cts
+type ZodTrait = {
+  _zod: {
+    def: any;
+    [k: string]: any;
+  };
+};
+interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
+  new (def: D): T;
+  init(inst: T, def: D): asserts inst is T;
+}
+declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
+  Parent?: typeof Class;
+}): $constructor<T, D>;
+declare const $brand: unique symbol;
+type $brand<T extends string | number | symbol = string | number | symbol> = {
+  [$brand]: { [k in T]: true };
+};
+type $ZodBranded<T extends SomeType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
+type input<T> = T extends {
+  _zod: {
+    input: any;
+  };
+} ? Required<T["_zod"]>["input"] : unknown;
+type output<T> = T extends {
+  _zod: {
+    output: any;
+  };
+} ? Required<T["_zod"]>["output"] : unknown;
+//#endregion
+//#region ../../node_modules/zod/v4/core/registries.d.cts
+declare const $output: unique symbol;
+type $output = typeof $output;
+declare const $input: unique symbol;
+type $input = typeof $input;
+type $replace<Meta, S extends $ZodType> = Meta extends $output ? output<S> : Meta extends $input ? input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends ((...args: infer P) => infer R) ? (...args: { [K in keyof P]: $replace<P[K], S> }) => $replace<R, S> : Meta extends object ? { [K in keyof Meta]: $replace<Meta[K], S> } : Meta;
+type MetadataType = Record<string, unknown> | undefined;
+declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
+  _meta: Meta;
+  _schema: Schema;
+  _map: Map<Schema, $replace<Meta, Schema>>;
+  _idmap: Map<string, Schema>;
+  add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
+  clear(): this;
+  remove(schema: Schema): this;
+  get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
+  has(schema: Schema): boolean;
+}
+interface JSONSchemaMeta {
+  id?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  deprecated?: boolean | undefined;
+  [k: string]: unknown;
+}
+interface GlobalMeta extends JSONSchemaMeta {}
+//#endregion
+//#region ../../node_modules/zod/v4/core/api.d.cts
+type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
+  error?: string | $ZodErrorMap<IssueTypes> | undefined; /** @deprecated This parameter is deprecated. Use `error` instead. */
+  message?: string | undefined;
+})>>>;
+type TypeParams<T extends $ZodType = $ZodType & {
+  _isst: never;
+}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+type CheckParams<T extends $ZodCheck = $ZodCheck, // & { _issc: never },
+AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
+type CheckStringFormatParams<T extends $ZodStringFormat = $ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
+type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
+type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail>;
+type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern">;
+type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern">;
+type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL>;
+type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji>;
+type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID>;
+type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID>;
+type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2>;
+type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID>;
+type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID>;
+type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID>;
+type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern">;
+type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern">;
+type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern">;
+type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern">;
+type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern">;
+type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern">;
+type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164>;
+type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern">;
+type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern">;
+type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern">;
+type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern">;
+type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration>;
+type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format">;
+type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value">;
+type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value">;
+type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value">;
+type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum">;
+type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum">;
+type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length">;
+type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern">;
+type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format">;
+type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format">;
+type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "pattern">;
+type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "pattern">;
+type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern">;
+type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
+type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
+type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+//#endregion
+//#region ../../node_modules/zod/v4/classic/errors.d.cts
+/** An Error-like class used to store Zod validation issues.  */
+interface ZodError<T = unknown> extends $ZodError<T> {
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format(): $ZodFormattedError<T>;
+  format<U>(mapper: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten(): $ZodFlattenedError<T>;
+  flatten<U>(mapper: (issue: $ZodIssue) => U): $ZodFlattenedError<T, U>;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssue(issue: $ZodIssue): void;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssues(issues: $ZodIssue[]): void;
+  /** @deprecated Check `err.issues.length === 0` instead. */
+  isEmpty: boolean;
+}
+declare const ZodError: $constructor<ZodError>;
+//#endregion
+//#region ../../node_modules/zod/v4/classic/parse.d.cts
+type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+type ZodSafeParseSuccess<T> = {
+  success: true;
+  data: T;
+  error?: never;
+};
+type ZodSafeParseError<T> = {
+  success: false;
+  data?: never;
+  error: ZodError<T>;
+};
+//#endregion
+//#region ../../node_modules/zod/v4/classic/schemas.d.cts
+interface RefinementCtx<T = unknown> extends ParsePayload<T> {
+  addIssue(arg: string | $ZodRawIssue | Partial<$ZodIssueCustom>): void;
+}
+interface ZodType$1<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
+  def: Internals["def"];
+  type: Internals["def"]["type"];
+  /** @deprecated Use `.def` instead. */
+  _def: Internals["def"];
+  /** @deprecated Use `z.output<typeof schema>` instead. */
+  _output: Internals["output"];
+  /** @deprecated Use `z.input<typeof schema>` instead. */
+  _input: Internals["input"];
+  check(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  clone(def?: Internals["def"], params?: {
+    parent: boolean;
+  }): this;
+  register<R extends $ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace<R["_meta"], this>?] : [$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
+  brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T>;
+  parse(data: unknown, params?: ParseContext<$ZodIssue>): output<this>;
+  safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+  parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+  safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+  spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<this>>>;
+  refine(check: (arg: output<this>) => unknown | Promise<unknown>, params?: string | $ZodCustomParams): this;
+  /** @deprecated Use `.check()` instead. */
+  superRefine(refinement: (arg: output<this>, ctx: RefinementCtx<output<this>>) => void | Promise<void>): this;
+  overwrite(fn: (x: output<this>) => output<this>): this;
+  optional(): ZodOptional<this>;
+  nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
+  nullable(): ZodNullable<this>;
+  nullish(): ZodOptional<ZodNullable<this>>;
+  default(def: output<this>): ZodDefault<this>;
+  default(def: () => NoUndefined<output<this>>): ZodDefault<this>;
+  prefault(def: () => input<this>): ZodPrefault<this>;
+  prefault(def: input<this>): ZodPrefault<this>;
+  array(): ZodArray<this>;
+  or<T extends SomeType>(option: T): ZodUnion<[this, T]>;
+  and<T extends SomeType>(incoming: T): ZodIntersection<this, T>;
+  transform<NewOut>(transform: (arg: output<this>, ctx: RefinementCtx<output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output<this>>>;
+  catch(def: output<this>): ZodCatch<this>;
+  catch(def: (ctx: $ZodCatchCtx) => output<this>): ZodCatch<this>;
+  pipe<T extends $ZodType<any, output<this>>>(target: T | $ZodType<any, output<this>>): ZodPipe<this, T>;
+  readonly(): ZodReadonly<this>;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
+  describe(description: string): this;
+  description?: string;
+  /** Returns the metadata associated with this instance in `z.globalRegistry` */
+  meta(): $replace<GlobalMeta, this> | undefined;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+  meta(data: $replace<GlobalMeta, this>): this;
+  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
+   *
+   * ```ts
+   * const schema = z.string().optional();
+   * const isOptional = schema.safeParse(undefined).success; // true
+   * ```
+   */
+  isOptional(): boolean;
+  /**
+   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
+   *
+   * ```ts
+   * const schema = z.string().nullable();
+   * const isNullable = schema.safeParse(null).success; // true
+   * ```
+   */
+  isNullable(): boolean;
+}
+interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType$1<any, any, Internals> {}
+declare const ZodType$1: $constructor<ZodType$1>;
+interface _ZodString<T extends $ZodStringInternals<unknown> = $ZodStringInternals<unknown>> extends _ZodType<T> {
+  format: string | null;
+  minLength: number | null;
+  maxLength: number | null;
+  regex(regex: RegExp, params?: string | $ZodCheckRegexParams): this;
+  includes(value: string, params?: $ZodCheckIncludesParams): this;
+  startsWith(value: string, params?: string | $ZodCheckStartsWithParams): this;
+  endsWith(value: string, params?: string | $ZodCheckEndsWithParams): this;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams): this;
+  lowercase(params?: string | $ZodCheckLowerCaseParams): this;
+  uppercase(params?: string | $ZodCheckUpperCaseParams): this;
+  trim(): this;
+  normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
+  toLowerCase(): this;
+  toUpperCase(): this;
+}
+/** @internal */
+declare const _ZodString: $constructor<_ZodString>;
+interface ZodString extends _ZodString<$ZodStringInternals<string>> {
+  /** @deprecated Use `z.email()` instead. */
+  email(params?: string | $ZodCheckEmailParams): this;
+  /** @deprecated Use `z.url()` instead. */
+  url(params?: string | $ZodCheckURLParams): this;
+  /** @deprecated Use `z.jwt()` instead. */
+  jwt(params?: string | $ZodCheckJWTParams): this;
+  /** @deprecated Use `z.emoji()` instead. */
+  emoji(params?: string | $ZodCheckEmojiParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | $ZodCheckGUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuid(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv4(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv6(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv7(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.nanoid()` instead. */
+  nanoid(params?: string | $ZodCheckNanoIDParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | $ZodCheckGUIDParams): this;
+  /** @deprecated Use `z.cuid()` instead. */
+  cuid(params?: string | $ZodCheckCUIDParams): this;
+  /** @deprecated Use `z.cuid2()` instead. */
+  cuid2(params?: string | $ZodCheckCUID2Params): this;
+  /** @deprecated Use `z.ulid()` instead. */
+  ulid(params?: string | $ZodCheckULIDParams): this;
+  /** @deprecated Use `z.base64()` instead. */
+  base64(params?: string | $ZodCheckBase64Params): this;
+  /** @deprecated Use `z.base64url()` instead. */
+  base64url(params?: string | $ZodCheckBase64URLParams): this;
+  /** @deprecated Use `z.xid()` instead. */
+  xid(params?: string | $ZodCheckXIDParams): this;
+  /** @deprecated Use `z.ksuid()` instead. */
+  ksuid(params?: string | $ZodCheckKSUIDParams): this;
+  /** @deprecated Use `z.ipv4()` instead. */
+  ipv4(params?: string | $ZodCheckIPv4Params): this;
+  /** @deprecated Use `z.ipv6()` instead. */
+  ipv6(params?: string | $ZodCheckIPv6Params): this;
+  /** @deprecated Use `z.cidrv4()` instead. */
+  cidrv4(params?: string | $ZodCheckCIDRv4Params): this;
+  /** @deprecated Use `z.cidrv6()` instead. */
+  cidrv6(params?: string | $ZodCheckCIDRv6Params): this;
+  /** @deprecated Use `z.e164()` instead. */
+  e164(params?: string | $ZodCheckE164Params): this;
+  /** @deprecated Use `z.iso.datetime()` instead. */
+  datetime(params?: string | $ZodCheckISODateTimeParams): this;
+  /** @deprecated Use `z.iso.date()` instead. */
+  date(params?: string | $ZodCheckISODateParams): this;
+  /** @deprecated Use `z.iso.time()` instead. */
+  time(params?: string | $ZodCheckISOTimeParams): this;
+  /** @deprecated Use `z.iso.duration()` instead. */
+  duration(params?: string | $ZodCheckISODurationParams): this;
+}
+declare const ZodString: $constructor<ZodString>;
+interface _ZodNumber<Internals extends $ZodNumberInternals = $ZodNumberInternals> extends _ZodType<Internals> {
+  gt(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+  /** Identical to .min() */
+  gte(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+  min(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+  lt(value: number, params?: string | $ZodCheckLessThanParams): this;
+  /** Identical to .max() */
+  lte(value: number, params?: string | $ZodCheckLessThanParams): this;
+  max(value: number, params?: string | $ZodCheckLessThanParams): this;
+  /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
+  int(params?: string | $ZodCheckNumberFormatParams): this;
+  /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
+  safe(params?: string | $ZodCheckNumberFormatParams): this;
+  positive(params?: string | $ZodCheckGreaterThanParams): this;
+  nonnegative(params?: string | $ZodCheckGreaterThanParams): this;
+  negative(params?: string | $ZodCheckLessThanParams): this;
+  nonpositive(params?: string | $ZodCheckLessThanParams): this;
+  multipleOf(value: number, params?: string | $ZodCheckMultipleOfParams): this;
+  /** @deprecated Use `.multipleOf()` instead. */
+  step(value: number, params?: string | $ZodCheckMultipleOfParams): this;
+  /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
+  finite(params?: unknown): this;
+  minValue: number | null;
+  maxValue: number | null;
+  /** @deprecated Check the `format` property instead.  */
+  isInt: boolean;
+  /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
+  isFinite: boolean;
+  format: string | null;
+}
+interface ZodNumber extends _ZodNumber<$ZodNumberInternals<number>> {}
+declare const ZodNumber: $constructor<ZodNumber>;
+interface _ZodBoolean<T extends $ZodBooleanInternals = $ZodBooleanInternals> extends _ZodType<T> {}
+interface ZodBoolean extends _ZodBoolean<$ZodBooleanInternals<boolean>> {}
+declare const ZodBoolean: $constructor<ZodBoolean>;
+interface ZodUnknown extends _ZodType<$ZodUnknownInternals> {}
+declare const ZodUnknown: $constructor<ZodUnknown>;
+interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T>>, $ZodArray<T> {
+  element: T;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+  unwrap(): T;
+}
+declare const ZodArray: $constructor<ZodArray>;
+interface ZodObject< /** @ts-ignore Cast variance */out Shape extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfig = $strip> extends _ZodType<$ZodObjectInternals<Shape, Config>>, $ZodObject<Shape, Config> {
+  shape: Shape;
+  keyof(): ZodEnum<ToEnum<keyof Shape & string>>;
+  /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+  catchall<T extends SomeType>(schema: T): ZodObject<Shape, $catchall<T>>;
+  /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+  passthrough(): ZodObject<Shape, $loose>;
+  /** Consider `z.looseObject(A.shape)` instead */
+  loose(): ZodObject<Shape, $loose>;
+  /** Consider `z.strictObject(A.shape)` instead */
+  strict(): ZodObject<Shape, $strict>;
+  /** This is the default behavior. This method call is likely unnecessary. */
+  strip(): ZodObject<Shape, $strip>;
+  extend<U extends $ZodLooseShape & Partial<Record<keyof Shape, SomeType>>>(shape: U): ZodObject<Extend<Shape, U>, Config>;
+  /**
+   * @deprecated Use spread syntax and the `.shape` property to combine two object schemas:
+   *
+   * ```ts
+   * const A = z.object({ a: z.string() });
+   * const B = z.object({ b: z.number() });
+   *
+   * const C = z.object({
+   *    ...A.shape,
+   *    ...B.shape
+   * });
+   * ```
+   */
+  merge<U extends ZodObject>(other: U): ZodObject<Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
+  pick<M extends Mask<keyof Shape>>(mask: M): ZodObject<Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  omit<M extends Mask<keyof Shape>>(mask: M): ZodObject<Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  partial(): ZodObject<{ [k in keyof Shape]: ZodOptional<Shape[k]> }, Config>;
+  partial<M extends Mask<keyof Shape>>(mask: M): ZodObject<{ [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k] }, Config>;
+  required(): ZodObject<{ [k in keyof Shape]: ZodNonOptional<Shape[k]> }, Config>;
+  required<M extends Mask<keyof Shape>>(mask: M): ZodObject<{ [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k] }, Config>;
+}
+declare const ZodObject: $constructor<ZodObject>;
+interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
+  options: T;
+}
+declare const ZodUnion: $constructor<ZodUnion>;
+interface ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[]> extends ZodUnion<Options>, $ZodDiscriminatedUnion<Options> {
+  _zod: $ZodDiscriminatedUnionInternals<Options>;
+}
+declare const ZodDiscriminatedUnion: $constructor<ZodDiscriminatedUnion>;
+interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {}
+declare const ZodIntersection: $constructor<ZodIntersection>;
+interface ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends _ZodType<$ZodRecordInternals<Key, Value>>, $ZodRecord<Key, Value> {
+  keyType: Key;
+  valueType: Value;
+}
+declare const ZodRecord: $constructor<ZodRecord>;
+interface ZodEnum< /** @ts-ignore Cast variance */out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
+  enum: T;
+  options: Array<T[keyof T]>;
+  extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Pick<T, U[number]>>>;
+  exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
+}
+declare const ZodEnum: $constructor<ZodEnum>;
+interface ZodLiteral<T extends Literal = Literal> extends _ZodType<$ZodLiteralInternals<T>>, $ZodLiteral<T> {
+  values: Set<T>;
+  /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+  value: T;
+}
+declare const ZodLiteral: $constructor<ZodLiteral>;
+interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {}
+declare const ZodTransform: $constructor<ZodTransform>;
+interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+  unwrap(): T;
+}
+declare const ZodOptional: $constructor<ZodOptional>;
+interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+  unwrap(): T;
+}
+declare const ZodNullable: $constructor<ZodNullable>;
+interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeDefault(): T;
+}
+declare const ZodDefault: $constructor<ZodDefault>;
+interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+  unwrap(): T;
+}
+declare const ZodPrefault: $constructor<ZodPrefault>;
+interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+  unwrap(): T;
+}
+declare const ZodNonOptional: $constructor<ZodNonOptional>;
+interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeCatch(): T;
+}
+declare const ZodCatch: $constructor<ZodCatch>;
+interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+  in: A;
+  out: B;
+}
+declare const ZodPipe: $constructor<ZodPipe>;
+interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {}
+declare const ZodReadonly: $constructor<ZodReadonly>;
+interface ZodLazy<T extends SomeType = $ZodType> extends _ZodType<$ZodLazyInternals<T>>, $ZodLazy<T> {
+  unwrap(): T;
+}
+declare const ZodLazy: $constructor<ZodLazy>;
+interface ZodCustom<O = unknown, I = unknown> extends _ZodType<$ZodCustomInternals<O, I>>, $ZodCustom<O, I> {}
+declare const ZodCustom: $constructor<ZodCustom>;
+//#endregion
 //#region src/stepFunctions/codeExecutionLambda/lambdaClient.d.ts
 type LambdaInvocationResult = {
   statusCode: number;
@@ -1027,7 +1766,7 @@ declare enum StepFunctionName {
   EMIT_EVENT = "emit_event",
   BROWSER_USE = "browser_use",
   CODE_EXECUTION_LAMBDA = "code_execution_lambda",
-  SIGN_JWT = "sign_jwt",
+  SIGN_JWT = "sign_jwt"
 }
 declare const stepFunctions: {
   typecast: {
@@ -1036,10 +1775,10 @@ declare const stepFunctions: {
     };
     v2: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        fields: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          targetFieldKey: zod_v40.ZodString;
-          type: zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        fields: ZodOptional<ZodArray<ZodObject<{
+          targetFieldKey: ZodString;
+          type: ZodEnum<{
             string: "string";
             number: "number";
             boolean: "boolean";
@@ -1047,17 +1786,17 @@ declare const stepFunctions: {
             datetime_string: "datetime_string";
             enum: "enum";
           }>;
-          array: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-          custom: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-          hidden: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-          properties: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodLazy<any>>>;
-          requiredScopes: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodString>>;
-        }, zod_v4_core0.$strip>>>;
-        dataSource: zod_v40.ZodString;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodObject<{
-        data: zod_v40.ZodUnknown;
-      }, zod_v4_core0.$strip>;
+          array: ZodDefault<ZodBoolean>;
+          custom: ZodDefault<ZodBoolean>;
+          hidden: ZodDefault<ZodBoolean>;
+          properties: ZodOptional<ZodArray<ZodLazy<any>>>;
+          requiredScopes: ZodOptional<ZodArray<ZodString>>;
+        }, $strip>>>;
+        dataSource: ZodString;
+      }, $strip>;
+      outputSchema: ZodObject<{
+        data: ZodUnknown;
+      }, $strip>;
     };
   };
   map_fields: {
@@ -1066,13 +1805,13 @@ declare const stepFunctions: {
     };
     v2: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        fields: zod_v40.ZodArray<zod_v40.ZodObject<{
-          targetFieldKey: zod_v40.ZodString;
-          alias: zod_v40.ZodOptional<zod_v40.ZodString>;
-          expression: zod_v40.ZodOptional<zod_v40.ZodString>;
-          values: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-          type: zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        fields: ZodArray<ZodObject<{
+          targetFieldKey: ZodString;
+          alias: ZodOptional<ZodString>;
+          expression: ZodOptional<ZodString>;
+          values: ZodOptional<ZodUnknown>;
+          type: ZodEnum<{
             string: "string";
             number: "number";
             boolean: "boolean";
@@ -1080,788 +1819,788 @@ declare const stepFunctions: {
             datetime_string: "datetime_string";
             enum: "enum";
           }>;
-          array: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-          custom: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-          hidden: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-          enumMapper: zod_v40.ZodOptional<zod_v40.ZodObject<{
-            matcher: zod_v40.ZodUnion<[zod_v40.ZodString, zod_v40.ZodArray<zod_v40.ZodObject<{
-              matchExpression: zod_v40.ZodString;
-              value: zod_v40.ZodString;
-            }, zod_v4_core0.$strict>>]>;
-          }, zod_v4_core0.$strict>>;
-          properties: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodLazy<any>>>;
-          requiredScopes: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodString>>;
-        }, zod_v4_core0.$strict>>;
-        dataSource: zod_v40.ZodString;
-        externalSources: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodObject<{
-        data: zod_v40.ZodUnknown;
-      }, zod_v4_core0.$strip>;
+          array: ZodDefault<ZodBoolean>;
+          custom: ZodDefault<ZodBoolean>;
+          hidden: ZodDefault<ZodBoolean>;
+          enumMapper: ZodOptional<ZodObject<{
+            matcher: ZodUnion<[ZodString, ZodArray<ZodObject<{
+              matchExpression: ZodString;
+              value: ZodString;
+            }, $strict>>]>;
+          }, $strict>>;
+          properties: ZodOptional<ZodArray<ZodLazy<any>>>;
+          requiredScopes: ZodOptional<ZodArray<ZodString>>;
+        }, $strict>>;
+        dataSource: ZodString;
+        externalSources: ZodOptional<ZodRecord<ZodString, ZodString>>;
+      }, $strip>;
+      outputSchema: ZodObject<{
+        data: ZodUnknown;
+      }, $strip>;
     };
   };
   request: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        baseUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-        url: zod_v40.ZodString;
-        method: zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        baseUrl: ZodOptional<ZodString>;
+        url: ZodString;
+        method: ZodEnum<{
           get: "get";
           post: "post";
           put: "put";
           delete: "delete";
           patch: "patch";
         }>;
-        authorization: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"none">;
-          signing: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"aws4">;
-            service: zod_v40.ZodString;
-            region: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"hmac">;
-            algorithm: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+        authorization: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+          type: ZodLiteral<"none">;
+          signing: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+            strategy: ZodLiteral<"aws4">;
+            service: ZodString;
+            region: ZodOptional<ZodString>;
+          }, $strict>, ZodObject<{
+            strategy: ZodLiteral<"hmac">;
+            algorithm: ZodOptional<ZodEnum<{
               sha256: "sha256";
               sha512: "sha512";
             }>>;
-            headerName: zod_v40.ZodOptional<zod_v40.ZodString>;
-            prefix: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>]>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"basic">;
-          username: zod_v40.ZodOptional<zod_v40.ZodString>;
-          password: zod_v40.ZodOptional<zod_v40.ZodString>;
-          encoding: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"bearer">;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"oauth2">;
-          authorizationUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          authorizationParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          tokenParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          tokenRefreshExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-          scopes: zod_v40.ZodOptional<zod_v40.ZodString>;
-          scopeDelimiter: zod_v40.ZodOptional<zod_v40.ZodString>;
-          customHeaders: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          pkce: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          additionalTokenFields: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodOptional<zod_v40.ZodString>>>;
-          issuer: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>]>>;
-        certificates: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          certs: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodString>>;
-          keys: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodString>>;
-        }, zod_v4_core0.$strict>>;
-        saml: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          objectKey: zod_v40.ZodString;
-          key: zod_v40.ZodString;
-          clientId: zod_v40.ZodString;
-          cert: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-          issuer: zod_v40.ZodOptional<zod_v40.ZodString>;
-          lifetime: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          nameId: zod_v40.ZodOptional<zod_v40.ZodString>;
-          audience: zod_v40.ZodOptional<zod_v40.ZodString>;
-          nameIdentifierFormat: zod_v40.ZodOptional<zod_v40.ZodString>;
-          tokenEndpoint: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>;
-        response: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          collection: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          indexField: zod_v40.ZodOptional<zod_v40.ZodString>;
-          dataKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>;
-        customErrors: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          receivedStatus: zod_v40.ZodNumber;
-          targetStatus: zod_v40.ZodNumber;
-          message: zod_v40.ZodOptional<zod_v40.ZodString>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>>;
-        args: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          name: zod_v40.ZodString;
-          value: zod_v40.ZodUnknown;
-          in: zod_v40.ZodEnum<{
+            headerName: ZodOptional<ZodString>;
+            prefix: ZodOptional<ZodString>;
+          }, $strict>]>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"basic">;
+          username: ZodOptional<ZodString>;
+          password: ZodOptional<ZodString>;
+          encoding: ZodOptional<ZodString>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"bearer">;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"oauth2">;
+          authorizationUrl: ZodOptional<ZodString>;
+          authorizationParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenUrl: ZodOptional<ZodString>;
+          tokenParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenExpiresIn: ZodOptional<ZodNumber>;
+          tokenRefreshExpiresIn: ZodOptional<ZodNumber>;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+          scopes: ZodOptional<ZodString>;
+          scopeDelimiter: ZodOptional<ZodString>;
+          customHeaders: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          pkce: ZodOptional<ZodBoolean>;
+          additionalTokenFields: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodString>>>;
+          issuer: ZodOptional<ZodString>;
+        }, $strict>]>>;
+        certificates: ZodOptional<ZodObject<{
+          certs: ZodOptional<ZodArray<ZodString>>;
+          keys: ZodOptional<ZodArray<ZodString>>;
+        }, $strict>>;
+        saml: ZodOptional<ZodObject<{
+          objectKey: ZodString;
+          key: ZodString;
+          clientId: ZodString;
+          cert: ZodOptional<ZodUnknown>;
+          issuer: ZodOptional<ZodString>;
+          lifetime: ZodOptional<ZodNumber>;
+          nameId: ZodOptional<ZodString>;
+          audience: ZodOptional<ZodString>;
+          nameIdentifierFormat: ZodOptional<ZodString>;
+          tokenEndpoint: ZodOptional<ZodString>;
+        }, $strict>>;
+        response: ZodOptional<ZodObject<{
+          collection: ZodOptional<ZodBoolean>;
+          indexField: ZodOptional<ZodString>;
+          dataKey: ZodOptional<ZodString>;
+        }, $strict>>;
+        customErrors: ZodOptional<ZodArray<ZodObject<{
+          receivedStatus: ZodNumber;
+          targetStatus: ZodNumber;
+          message: ZodOptional<ZodString>;
+          condition: ZodOptional<ZodString>;
+        }, $strict>>>;
+        args: ZodOptional<ZodArray<ZodObject<{
+          name: ZodString;
+          value: ZodUnknown;
+          in: ZodEnum<{
             query: "query";
             body: "body";
             headers: "headers";
           }>;
-          spread: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-          arrayFormat: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+          spread: ZodOptional<ZodBoolean>;
+          condition: ZodOptional<ZodString>;
+          arrayFormat: ZodOptional<ZodEnum<{
             repeat: "repeat";
             brackets: "brackets";
             comma: "comma";
             stringify: "stringify";
           }>>;
-        }, zod_v4_core0.$strict>>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodOptional<zod_v40.ZodObject<{
-        data: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        raw: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        statusCode: zod_v40.ZodNumber;
-        message: zod_v40.ZodOptional<zod_v40.ZodString>;
-      }, zod_v4_core0.$strict>>;
+        }, $strict>>>;
+      }, $strip>;
+      outputSchema: ZodOptional<ZodObject<{
+        data: ZodOptional<ZodUnknown>;
+        raw: ZodOptional<ZodUnknown>;
+        statusCode: ZodNumber;
+        message: ZodOptional<ZodString>;
+      }, $strict>>;
     };
   };
   group_data: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        stepsDataToGroup: zod_v40.ZodArray<zod_v40.ZodString>;
-        isSingleRecord: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodObject<{
-        data: zod_v40.ZodUnknown;
-      }, zod_v4_core0.$strip>;
+      inputSchema: ZodObject<{
+        stepsDataToGroup: ZodArray<ZodString>;
+        isSingleRecord: ZodOptional<ZodBoolean>;
+      }, $strip>;
+      outputSchema: ZodObject<{
+        data: ZodUnknown;
+      }, $strip>;
     };
   };
   paginated_request: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        baseUrl: zod_v40.ZodString;
-        url: zod_v40.ZodString;
-        method: zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        baseUrl: ZodString;
+        url: ZodString;
+        method: ZodEnum<{
           get: "get";
           post: "post";
           put: "put";
           delete: "delete";
           patch: "patch";
         }>;
-        saml: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          objectKey: zod_v40.ZodString;
-          key: zod_v40.ZodString;
-          clientId: zod_v40.ZodString;
-          cert: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-          issuer: zod_v40.ZodOptional<zod_v40.ZodString>;
-          lifetime: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          nameId: zod_v40.ZodOptional<zod_v40.ZodString>;
-          audience: zod_v40.ZodOptional<zod_v40.ZodString>;
-          nameIdentifierFormat: zod_v40.ZodOptional<zod_v40.ZodString>;
-          tokenEndpoint: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>;
-        response: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          indexField: zod_v40.ZodOptional<zod_v40.ZodString>;
-          dataKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-          nextKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-          nextKeyIn: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+        saml: ZodOptional<ZodObject<{
+          objectKey: ZodString;
+          key: ZodString;
+          clientId: ZodString;
+          cert: ZodOptional<ZodUnknown>;
+          issuer: ZodOptional<ZodString>;
+          lifetime: ZodOptional<ZodNumber>;
+          nameId: ZodOptional<ZodString>;
+          audience: ZodOptional<ZodString>;
+          nameIdentifierFormat: ZodOptional<ZodString>;
+          tokenEndpoint: ZodOptional<ZodString>;
+        }, $strict>>;
+        response: ZodOptional<ZodObject<{
+          indexField: ZodOptional<ZodString>;
+          dataKey: ZodOptional<ZodString>;
+          nextKey: ZodOptional<ZodString>;
+          nextKeyIn: ZodOptional<ZodEnum<{
             data: "data";
             headers: "headers";
           }>>;
-        }, zod_v4_core0.$strict>>;
-        iterator: zod_v40.ZodObject<{
-          key: zod_v40.ZodString;
-          in: zod_v40.ZodEnum<{
+        }, $strict>>;
+        iterator: ZodObject<{
+          key: ZodString;
+          in: ZodEnum<{
             query: "query";
             body: "body";
             headers: "headers";
           }>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-          mode: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+          condition: ZodOptional<ZodString>;
+          mode: ZodOptional<ZodEnum<{
             cursor: "cursor";
             offset: "offset";
           }>>;
-        }, zod_v4_core0.$strict>;
-        cursor: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          token: zod_v40.ZodNullable<zod_v40.ZodOptional<zod_v40.ZodString>>;
-          position: zod_v40.ZodNullable<zod_v40.ZodOptional<zod_v40.ZodNumber>>;
-        }, zod_v4_core0.$strict>>;
-        customErrors: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          receivedStatus: zod_v40.ZodNumber;
-          targetStatus: zod_v40.ZodNumber;
-          message: zod_v40.ZodOptional<zod_v40.ZodString>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>>;
-        args: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          name: zod_v40.ZodString;
-          value: zod_v40.ZodUnknown;
-          in: zod_v40.ZodEnum<{
+        }, $strict>;
+        cursor: ZodOptional<ZodObject<{
+          token: ZodNullable<ZodOptional<ZodString>>;
+          position: ZodNullable<ZodOptional<ZodNumber>>;
+        }, $strict>>;
+        customErrors: ZodOptional<ZodArray<ZodObject<{
+          receivedStatus: ZodNumber;
+          targetStatus: ZodNumber;
+          message: ZodOptional<ZodString>;
+          condition: ZodOptional<ZodString>;
+        }, $strict>>>;
+        args: ZodOptional<ZodArray<ZodObject<{
+          name: ZodString;
+          value: ZodUnknown;
+          in: ZodEnum<{
             query: "query";
             body: "body";
             headers: "headers";
           }>;
-          spread: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-          arrayFormat: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+          spread: ZodOptional<ZodBoolean>;
+          condition: ZodOptional<ZodString>;
+          arrayFormat: ZodOptional<ZodEnum<{
             repeat: "repeat";
             brackets: "brackets";
             comma: "comma";
             stringify: "stringify";
           }>>;
-        }, zod_v4_core0.$strict>>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodOptional<zod_v40.ZodObject<{
-        data: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        raw: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        statusCode: zod_v40.ZodNumber;
-        message: zod_v40.ZodOptional<zod_v40.ZodString>;
-        next: zod_v40.ZodNullable<zod_v40.ZodOptional<zod_v40.ZodString>>;
-        position: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-      }, zod_v4_core0.$strict>>;
+        }, $strict>>>;
+      }, $strip>;
+      outputSchema: ZodOptional<ZodObject<{
+        data: ZodOptional<ZodUnknown>;
+        raw: ZodOptional<ZodUnknown>;
+        statusCode: ZodNumber;
+        message: ZodOptional<ZodString>;
+        next: ZodNullable<ZodOptional<ZodString>>;
+        position: ZodOptional<ZodNumber>;
+      }, $strict>>;
     };
   };
   soap_request: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        baseUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-        url: zod_v40.ZodString;
-        method: zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        baseUrl: ZodOptional<ZodString>;
+        url: ZodString;
+        method: ZodEnum<{
           get: "get";
           post: "post";
           put: "put";
           delete: "delete";
           patch: "patch";
         }>;
-        authorization: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"none">;
-          signing: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"aws4">;
-            service: zod_v40.ZodString;
-            region: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"hmac">;
-            algorithm: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+        authorization: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+          type: ZodLiteral<"none">;
+          signing: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+            strategy: ZodLiteral<"aws4">;
+            service: ZodString;
+            region: ZodOptional<ZodString>;
+          }, $strict>, ZodObject<{
+            strategy: ZodLiteral<"hmac">;
+            algorithm: ZodOptional<ZodEnum<{
               sha256: "sha256";
               sha512: "sha512";
             }>>;
-            headerName: zod_v40.ZodOptional<zod_v40.ZodString>;
-            prefix: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>]>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"basic">;
-          username: zod_v40.ZodOptional<zod_v40.ZodString>;
-          password: zod_v40.ZodOptional<zod_v40.ZodString>;
-          encoding: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"bearer">;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"oauth2">;
-          authorizationUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          authorizationParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          tokenParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          tokenRefreshExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-          scopes: zod_v40.ZodOptional<zod_v40.ZodString>;
-          scopeDelimiter: zod_v40.ZodOptional<zod_v40.ZodString>;
-          customHeaders: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          pkce: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          additionalTokenFields: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodOptional<zod_v40.ZodString>>>;
-          issuer: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>]>>;
-        envelope: zod_v40.ZodOptional<zod_v40.ZodUnion<readonly [zod_v40.ZodString, zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodUnknown>]>>;
-        namespaces: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          namespaceIdentifier: zod_v40.ZodString;
-          namespace: zod_v40.ZodString;
-        }, zod_v4_core0.$strict>>>;
-        soapOperation: zod_v40.ZodOptional<zod_v40.ZodString>;
-        soapAction: zod_v40.ZodOptional<zod_v40.ZodString>;
-        useSoapContext: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        response: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          collection: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          indexField: zod_v40.ZodOptional<zod_v40.ZodString>;
-          dataKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>;
-        customErrors: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          receivedStatus: zod_v40.ZodNumber;
-          targetStatus: zod_v40.ZodNumber;
-          message: zod_v40.ZodOptional<zod_v40.ZodString>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>>;
-        args: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          name: zod_v40.ZodString;
-          value: zod_v40.ZodUnknown;
-          in: zod_v40.ZodEnum<{
+            headerName: ZodOptional<ZodString>;
+            prefix: ZodOptional<ZodString>;
+          }, $strict>]>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"basic">;
+          username: ZodOptional<ZodString>;
+          password: ZodOptional<ZodString>;
+          encoding: ZodOptional<ZodString>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"bearer">;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"oauth2">;
+          authorizationUrl: ZodOptional<ZodString>;
+          authorizationParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenUrl: ZodOptional<ZodString>;
+          tokenParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenExpiresIn: ZodOptional<ZodNumber>;
+          tokenRefreshExpiresIn: ZodOptional<ZodNumber>;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+          scopes: ZodOptional<ZodString>;
+          scopeDelimiter: ZodOptional<ZodString>;
+          customHeaders: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          pkce: ZodOptional<ZodBoolean>;
+          additionalTokenFields: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodString>>>;
+          issuer: ZodOptional<ZodString>;
+        }, $strict>]>>;
+        envelope: ZodOptional<ZodUnion<readonly [ZodString, ZodRecord<ZodString, ZodUnknown>]>>;
+        namespaces: ZodOptional<ZodArray<ZodObject<{
+          namespaceIdentifier: ZodString;
+          namespace: ZodString;
+        }, $strict>>>;
+        soapOperation: ZodOptional<ZodString>;
+        soapAction: ZodOptional<ZodString>;
+        useSoapContext: ZodDefault<ZodOptional<ZodBoolean>>;
+        response: ZodOptional<ZodObject<{
+          collection: ZodOptional<ZodBoolean>;
+          indexField: ZodOptional<ZodString>;
+          dataKey: ZodOptional<ZodString>;
+        }, $strict>>;
+        customErrors: ZodOptional<ZodArray<ZodObject<{
+          receivedStatus: ZodNumber;
+          targetStatus: ZodNumber;
+          message: ZodOptional<ZodString>;
+          condition: ZodOptional<ZodString>;
+        }, $strict>>>;
+        args: ZodOptional<ZodArray<ZodObject<{
+          name: ZodString;
+          value: ZodUnknown;
+          in: ZodEnum<{
             query: "query";
             body: "body";
             headers: "headers";
           }>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-          arrayFormat: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+          condition: ZodOptional<ZodString>;
+          arrayFormat: ZodOptional<ZodEnum<{
             repeat: "repeat";
             brackets: "brackets";
             comma: "comma";
             stringify: "stringify";
           }>>;
-        }, zod_v4_core0.$strict>>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodOptional<zod_v40.ZodObject<{
-        data: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        raw: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        statusCode: zod_v40.ZodNumber;
-        message: zod_v40.ZodOptional<zod_v40.ZodString>;
-      }, zod_v4_core0.$strict>>;
+        }, $strict>>>;
+      }, $strip>;
+      outputSchema: ZodOptional<ZodObject<{
+        data: ZodOptional<ZodUnknown>;
+        raw: ZodOptional<ZodUnknown>;
+        statusCode: ZodNumber;
+        message: ZodOptional<ZodString>;
+      }, $strict>>;
     };
   };
   soap_paginated_request: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        baseUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-        url: zod_v40.ZodString;
-        method: zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        baseUrl: ZodOptional<ZodString>;
+        url: ZodString;
+        method: ZodEnum<{
           get: "get";
           post: "post";
           put: "put";
           delete: "delete";
           patch: "patch";
         }>;
-        authorization: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"none">;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"basic">;
-          username: zod_v40.ZodOptional<zod_v40.ZodString>;
-          password: zod_v40.ZodOptional<zod_v40.ZodString>;
-          encoding: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"bearer">;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"oauth2">;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        }, zod_v4_core0.$strict>]>>;
-        envelope: zod_v40.ZodOptional<zod_v40.ZodUnion<readonly [zod_v40.ZodString, zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodUnknown>]>>;
-        namespaces: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          namespaceIdentifier: zod_v40.ZodString;
-          namespace: zod_v40.ZodString;
-        }, zod_v4_core0.$strict>>>;
-        soapOperation: zod_v40.ZodOptional<zod_v40.ZodString>;
-        soapAction: zod_v40.ZodOptional<zod_v40.ZodString>;
-        useSoapContext: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        response: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          collection: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          indexField: zod_v40.ZodOptional<zod_v40.ZodString>;
-          dataKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-          nextKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-          nextKeyIn: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+        authorization: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+          type: ZodLiteral<"none">;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"basic">;
+          username: ZodOptional<ZodString>;
+          password: ZodOptional<ZodString>;
+          encoding: ZodOptional<ZodString>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"bearer">;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"oauth2">;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+        }, $strict>]>>;
+        envelope: ZodOptional<ZodUnion<readonly [ZodString, ZodRecord<ZodString, ZodUnknown>]>>;
+        namespaces: ZodOptional<ZodArray<ZodObject<{
+          namespaceIdentifier: ZodString;
+          namespace: ZodString;
+        }, $strict>>>;
+        soapOperation: ZodOptional<ZodString>;
+        soapAction: ZodOptional<ZodString>;
+        useSoapContext: ZodDefault<ZodOptional<ZodBoolean>>;
+        response: ZodOptional<ZodObject<{
+          collection: ZodOptional<ZodBoolean>;
+          indexField: ZodOptional<ZodString>;
+          dataKey: ZodOptional<ZodString>;
+          nextKey: ZodOptional<ZodString>;
+          nextKeyIn: ZodOptional<ZodEnum<{
             data: "data";
             headers: "headers";
           }>>;
-        }, zod_v4_core0.$strict>>;
-        iterator: zod_v40.ZodObject<{
-          key: zod_v40.ZodString;
-          in: zod_v40.ZodEnum<{
+        }, $strict>>;
+        iterator: ZodObject<{
+          key: ZodString;
+          in: ZodEnum<{
             query: "query";
             body: "body";
             headers: "headers";
           }>;
-        }, zod_v4_core0.$strict>;
-        cursor: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          token: zod_v40.ZodNullable<zod_v40.ZodOptional<zod_v40.ZodString>>;
-          position: zod_v40.ZodNullable<zod_v40.ZodOptional<zod_v40.ZodNumber>>;
-        }, zod_v4_core0.$strict>>;
-        customErrors: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          receivedStatus: zod_v40.ZodNumber;
-          targetStatus: zod_v40.ZodNumber;
-          message: zod_v40.ZodOptional<zod_v40.ZodString>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>>;
-        args: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          name: zod_v40.ZodString;
-          value: zod_v40.ZodUnknown;
-          in: zod_v40.ZodEnum<{
+        }, $strict>;
+        cursor: ZodOptional<ZodObject<{
+          token: ZodNullable<ZodOptional<ZodString>>;
+          position: ZodNullable<ZodOptional<ZodNumber>>;
+        }, $strict>>;
+        customErrors: ZodOptional<ZodArray<ZodObject<{
+          receivedStatus: ZodNumber;
+          targetStatus: ZodNumber;
+          message: ZodOptional<ZodString>;
+          condition: ZodOptional<ZodString>;
+        }, $strict>>>;
+        args: ZodOptional<ZodArray<ZodObject<{
+          name: ZodString;
+          value: ZodUnknown;
+          in: ZodEnum<{
             query: "query";
             body: "body";
             headers: "headers";
           }>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-          arrayFormat: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+          condition: ZodOptional<ZodString>;
+          arrayFormat: ZodOptional<ZodEnum<{
             repeat: "repeat";
             brackets: "brackets";
             comma: "comma";
             stringify: "stringify";
           }>>;
-        }, zod_v4_core0.$strict>>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodOptional<zod_v40.ZodObject<{
-        data: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        raw: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        statusCode: zod_v40.ZodNumber;
-        message: zod_v40.ZodOptional<zod_v40.ZodString>;
-        next: zod_v40.ZodNullable<zod_v40.ZodOptional<zod_v40.ZodString>>;
-        position: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-      }, zod_v4_core0.$strict>>;
+        }, $strict>>>;
+      }, $strip>;
+      outputSchema: ZodOptional<ZodObject<{
+        data: ZodOptional<ZodUnknown>;
+        raw: ZodOptional<ZodUnknown>;
+        statusCode: ZodNumber;
+        message: ZodOptional<ZodString>;
+        next: ZodNullable<ZodOptional<ZodString>>;
+        position: ZodOptional<ZodNumber>;
+      }, $strict>>;
     };
   };
   static_values: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        values: zod_v40.ZodUnion<[zod_v40.ZodUnion<[zod_v40.ZodString, zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodUnknown>]>, zod_v40.ZodArray<zod_v40.ZodUnknown>]>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodObject<{
-        data: zod_v40.ZodUnknown;
-      }, zod_v4_core0.$strip>;
+      inputSchema: ZodObject<{
+        values: ZodUnion<[ZodUnion<[ZodString, ZodRecord<ZodString, ZodUnknown>]>, ZodArray<ZodUnknown>]>;
+      }, $strip>;
+      outputSchema: ZodObject<{
+        data: ZodUnknown;
+      }, $strip>;
     };
   };
   upload_file: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        baseUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-        url: zod_v40.ZodString;
-        method: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        baseUrl: ZodOptional<ZodString>;
+        url: ZodString;
+        method: ZodDefault<ZodEnum<{
           get: "get";
           post: "post";
           put: "put";
           delete: "delete";
           patch: "patch";
         }>>;
-        authorization: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"none">;
-          signing: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"aws4">;
-            service: zod_v40.ZodString;
-            region: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"hmac">;
-            algorithm: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+        authorization: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+          type: ZodLiteral<"none">;
+          signing: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+            strategy: ZodLiteral<"aws4">;
+            service: ZodString;
+            region: ZodOptional<ZodString>;
+          }, $strict>, ZodObject<{
+            strategy: ZodLiteral<"hmac">;
+            algorithm: ZodOptional<ZodEnum<{
               sha256: "sha256";
               sha512: "sha512";
             }>>;
-            headerName: zod_v40.ZodOptional<zod_v40.ZodString>;
-            prefix: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>]>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"basic">;
-          username: zod_v40.ZodOptional<zod_v40.ZodString>;
-          password: zod_v40.ZodOptional<zod_v40.ZodString>;
-          encoding: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"bearer">;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"oauth2">;
-          authorizationUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          authorizationParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          tokenParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          tokenRefreshExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-          scopes: zod_v40.ZodOptional<zod_v40.ZodString>;
-          scopeDelimiter: zod_v40.ZodOptional<zod_v40.ZodString>;
-          customHeaders: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          pkce: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          additionalTokenFields: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodOptional<zod_v40.ZodString>>>;
-          issuer: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>]>>;
-        file: zod_v40.ZodObject<{
-          fieldName: zod_v40.ZodString;
-          content: zod_v40.ZodString;
-          filename: zod_v40.ZodString;
-          contentType: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>;
-        additionalFields: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          name: zod_v40.ZodString;
-          value: zod_v40.ZodUnknown;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-          contentType: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>>;
-        response: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          collection: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          indexField: zod_v40.ZodOptional<zod_v40.ZodString>;
-          dataKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>;
-        customErrors: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          receivedStatus: zod_v40.ZodNumber;
-          targetStatus: zod_v40.ZodNumber;
-          message: zod_v40.ZodOptional<zod_v40.ZodString>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>>;
-        args: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          name: zod_v40.ZodString;
-          value: zod_v40.ZodUnknown;
-          in: zod_v40.ZodEnum<{
+            headerName: ZodOptional<ZodString>;
+            prefix: ZodOptional<ZodString>;
+          }, $strict>]>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"basic">;
+          username: ZodOptional<ZodString>;
+          password: ZodOptional<ZodString>;
+          encoding: ZodOptional<ZodString>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"bearer">;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"oauth2">;
+          authorizationUrl: ZodOptional<ZodString>;
+          authorizationParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenUrl: ZodOptional<ZodString>;
+          tokenParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenExpiresIn: ZodOptional<ZodNumber>;
+          tokenRefreshExpiresIn: ZodOptional<ZodNumber>;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+          scopes: ZodOptional<ZodString>;
+          scopeDelimiter: ZodOptional<ZodString>;
+          customHeaders: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          pkce: ZodOptional<ZodBoolean>;
+          additionalTokenFields: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodString>>>;
+          issuer: ZodOptional<ZodString>;
+        }, $strict>]>>;
+        file: ZodObject<{
+          fieldName: ZodString;
+          content: ZodString;
+          filename: ZodString;
+          contentType: ZodOptional<ZodString>;
+        }, $strict>;
+        additionalFields: ZodOptional<ZodArray<ZodObject<{
+          name: ZodString;
+          value: ZodUnknown;
+          condition: ZodOptional<ZodString>;
+          contentType: ZodOptional<ZodString>;
+        }, $strict>>>;
+        response: ZodOptional<ZodObject<{
+          collection: ZodOptional<ZodBoolean>;
+          indexField: ZodOptional<ZodString>;
+          dataKey: ZodOptional<ZodString>;
+        }, $strict>>;
+        customErrors: ZodOptional<ZodArray<ZodObject<{
+          receivedStatus: ZodNumber;
+          targetStatus: ZodNumber;
+          message: ZodOptional<ZodString>;
+          condition: ZodOptional<ZodString>;
+        }, $strict>>>;
+        args: ZodOptional<ZodArray<ZodObject<{
+          name: ZodString;
+          value: ZodUnknown;
+          in: ZodEnum<{
             query: "query";
             body: "body";
             headers: "headers";
           }>;
-          spread: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-          arrayFormat: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+          spread: ZodOptional<ZodBoolean>;
+          condition: ZodOptional<ZodString>;
+          arrayFormat: ZodOptional<ZodEnum<{
             repeat: "repeat";
             brackets: "brackets";
             comma: "comma";
             stringify: "stringify";
           }>>;
-        }, zod_v4_core0.$strict>>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodOptional<zod_v40.ZodObject<{
-        data: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        raw: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        statusCode: zod_v40.ZodNumber;
-        message: zod_v40.ZodOptional<zod_v40.ZodString>;
-      }, zod_v4_core0.$strict>>;
+        }, $strict>>>;
+      }, $strip>;
+      outputSchema: ZodOptional<ZodObject<{
+        data: ZodOptional<ZodUnknown>;
+        raw: ZodOptional<ZodUnknown>;
+        statusCode: ZodNumber;
+        message: ZodOptional<ZodString>;
+      }, $strict>>;
     };
   };
   upload_binary: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        baseUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-        url: zod_v40.ZodString;
-        method: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        baseUrl: ZodOptional<ZodString>;
+        url: ZodString;
+        method: ZodDefault<ZodEnum<{
           get: "get";
           post: "post";
           put: "put";
           delete: "delete";
           patch: "patch";
         }>>;
-        authorization: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"none">;
-          signing: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"aws4">;
-            service: zod_v40.ZodString;
-            region: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"hmac">;
-            algorithm: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+        authorization: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+          type: ZodLiteral<"none">;
+          signing: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+            strategy: ZodLiteral<"aws4">;
+            service: ZodString;
+            region: ZodOptional<ZodString>;
+          }, $strict>, ZodObject<{
+            strategy: ZodLiteral<"hmac">;
+            algorithm: ZodOptional<ZodEnum<{
               sha256: "sha256";
               sha512: "sha512";
             }>>;
-            headerName: zod_v40.ZodOptional<zod_v40.ZodString>;
-            prefix: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>]>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"basic">;
-          username: zod_v40.ZodOptional<zod_v40.ZodString>;
-          password: zod_v40.ZodOptional<zod_v40.ZodString>;
-          encoding: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"bearer">;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"oauth2">;
-          authorizationUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          authorizationParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          tokenParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          tokenRefreshExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-          scopes: zod_v40.ZodOptional<zod_v40.ZodString>;
-          scopeDelimiter: zod_v40.ZodOptional<zod_v40.ZodString>;
-          customHeaders: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          pkce: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          additionalTokenFields: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodOptional<zod_v40.ZodString>>>;
-          issuer: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>]>>;
-        binaryContent: zod_v40.ZodObject<{
-          content: zod_v40.ZodString;
-          contentType: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>;
-        response: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          collection: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          indexField: zod_v40.ZodOptional<zod_v40.ZodString>;
-          dataKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>;
-        customErrors: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          receivedStatus: zod_v40.ZodNumber;
-          targetStatus: zod_v40.ZodNumber;
-          message: zod_v40.ZodOptional<zod_v40.ZodString>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>>;
-        args: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          name: zod_v40.ZodString;
-          value: zod_v40.ZodUnknown;
-          in: zod_v40.ZodEnum<{
+            headerName: ZodOptional<ZodString>;
+            prefix: ZodOptional<ZodString>;
+          }, $strict>]>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"basic">;
+          username: ZodOptional<ZodString>;
+          password: ZodOptional<ZodString>;
+          encoding: ZodOptional<ZodString>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"bearer">;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"oauth2">;
+          authorizationUrl: ZodOptional<ZodString>;
+          authorizationParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenUrl: ZodOptional<ZodString>;
+          tokenParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenExpiresIn: ZodOptional<ZodNumber>;
+          tokenRefreshExpiresIn: ZodOptional<ZodNumber>;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+          scopes: ZodOptional<ZodString>;
+          scopeDelimiter: ZodOptional<ZodString>;
+          customHeaders: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          pkce: ZodOptional<ZodBoolean>;
+          additionalTokenFields: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodString>>>;
+          issuer: ZodOptional<ZodString>;
+        }, $strict>]>>;
+        binaryContent: ZodObject<{
+          content: ZodString;
+          contentType: ZodOptional<ZodString>;
+        }, $strict>;
+        response: ZodOptional<ZodObject<{
+          collection: ZodOptional<ZodBoolean>;
+          indexField: ZodOptional<ZodString>;
+          dataKey: ZodOptional<ZodString>;
+        }, $strict>>;
+        customErrors: ZodOptional<ZodArray<ZodObject<{
+          receivedStatus: ZodNumber;
+          targetStatus: ZodNumber;
+          message: ZodOptional<ZodString>;
+          condition: ZodOptional<ZodString>;
+        }, $strict>>>;
+        args: ZodOptional<ZodArray<ZodObject<{
+          name: ZodString;
+          value: ZodUnknown;
+          in: ZodEnum<{
             query: "query";
             body: "body";
             headers: "headers";
           }>;
-          spread: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-          arrayFormat: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+          spread: ZodOptional<ZodBoolean>;
+          condition: ZodOptional<ZodString>;
+          arrayFormat: ZodOptional<ZodEnum<{
             repeat: "repeat";
             brackets: "brackets";
             comma: "comma";
             stringify: "stringify";
           }>>;
-        }, zod_v4_core0.$strict>>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodOptional<zod_v40.ZodObject<{
-        data: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        raw: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        statusCode: zod_v40.ZodNumber;
-        message: zod_v40.ZodOptional<zod_v40.ZodString>;
-      }, zod_v4_core0.$strict>>;
+        }, $strict>>>;
+      }, $strip>;
+      outputSchema: ZodOptional<ZodObject<{
+        data: ZodOptional<ZodUnknown>;
+        raw: ZodOptional<ZodUnknown>;
+        statusCode: ZodNumber;
+        message: ZodOptional<ZodString>;
+      }, $strict>>;
     };
   };
   download_file: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        baseUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-        url: zod_v40.ZodString;
-        method: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        baseUrl: ZodOptional<ZodString>;
+        url: ZodString;
+        method: ZodDefault<ZodOptional<ZodEnum<{
           get: "get";
           post: "post";
           put: "put";
           delete: "delete";
           patch: "patch";
         }>>>;
-        authorization: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"none">;
-          signing: zod_v40.ZodOptional<zod_v40.ZodDiscriminatedUnion<[zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"aws4">;
-            service: zod_v40.ZodString;
-            region: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-            strategy: zod_v40.ZodLiteral<"hmac">;
-            algorithm: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+        authorization: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+          type: ZodLiteral<"none">;
+          signing: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+            strategy: ZodLiteral<"aws4">;
+            service: ZodString;
+            region: ZodOptional<ZodString>;
+          }, $strict>, ZodObject<{
+            strategy: ZodLiteral<"hmac">;
+            algorithm: ZodOptional<ZodEnum<{
               sha256: "sha256";
               sha512: "sha512";
             }>>;
-            headerName: zod_v40.ZodOptional<zod_v40.ZodString>;
-            prefix: zod_v40.ZodOptional<zod_v40.ZodString>;
-          }, zod_v4_core0.$strict>]>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"basic">;
-          username: zod_v40.ZodOptional<zod_v40.ZodString>;
-          password: zod_v40.ZodOptional<zod_v40.ZodString>;
-          encoding: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"bearer">;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        }, zod_v4_core0.$strict>, zod_v40.ZodObject<{
-          type: zod_v40.ZodLiteral<"oauth2">;
-          authorizationUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          authorizationParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-          tokenParams: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          tokenExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          tokenRefreshExpiresIn: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          token: zod_v40.ZodString;
-          includeBearer: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-          scopes: zod_v40.ZodOptional<zod_v40.ZodString>;
-          scopeDelimiter: zod_v40.ZodOptional<zod_v40.ZodString>;
-          customHeaders: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-          pkce: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          additionalTokenFields: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodOptional<zod_v40.ZodString>>>;
-          issuer: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>]>>;
-        responseMode: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodEnum<{
+            headerName: ZodOptional<ZodString>;
+            prefix: ZodOptional<ZodString>;
+          }, $strict>]>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"basic">;
+          username: ZodOptional<ZodString>;
+          password: ZodOptional<ZodString>;
+          encoding: ZodOptional<ZodString>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"bearer">;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+        }, $strict>, ZodObject<{
+          type: ZodLiteral<"oauth2">;
+          authorizationUrl: ZodOptional<ZodString>;
+          authorizationParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenUrl: ZodOptional<ZodString>;
+          tokenParams: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          tokenExpiresIn: ZodOptional<ZodNumber>;
+          tokenRefreshExpiresIn: ZodOptional<ZodNumber>;
+          token: ZodString;
+          includeBearer: ZodDefault<ZodOptional<ZodBoolean>>;
+          scopes: ZodOptional<ZodString>;
+          scopeDelimiter: ZodOptional<ZodString>;
+          customHeaders: ZodOptional<ZodRecord<ZodString, ZodString>>;
+          pkce: ZodOptional<ZodBoolean>;
+          additionalTokenFields: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodString>>>;
+          issuer: ZodOptional<ZodString>;
+        }, $strict>]>>;
+        responseMode: ZodDefault<ZodOptional<ZodEnum<{
           buffer: "buffer";
           stream: "stream";
         }>>>;
-        responseType: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodEnum<{
+        responseType: ZodDefault<ZodOptional<ZodEnum<{
           arraybuffer: "arraybuffer";
           blob: "blob";
           text: "text";
           json: "json";
         }>>>;
-        encoding: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodEnum<{
+        encoding: ZodDefault<ZodOptional<ZodEnum<{
           none: "none";
           raw: "raw";
           base64: "base64";
           utf8: "utf8";
           binary: "binary";
         }>>>;
-        response: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          dataKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-          fileNameKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-          contentTypeKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-          contentIsBase64: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-          urlKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-          forwardAuth: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        }, zod_v4_core0.$strict>>;
-        maxRedirects: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodNumber>>;
-        followRedirects: zod_v40.ZodDefault<zod_v40.ZodOptional<zod_v40.ZodBoolean>>;
-        customErrors: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          receivedStatus: zod_v40.ZodNumber;
-          targetStatus: zod_v40.ZodNumber;
-          message: zod_v40.ZodOptional<zod_v40.ZodString>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>>;
-        args: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          name: zod_v40.ZodString;
-          value: zod_v40.ZodUnknown;
-          in: zod_v40.ZodEnum<{
+        response: ZodOptional<ZodObject<{
+          dataKey: ZodOptional<ZodString>;
+          fileNameKey: ZodOptional<ZodString>;
+          contentTypeKey: ZodOptional<ZodString>;
+          contentIsBase64: ZodDefault<ZodOptional<ZodBoolean>>;
+          urlKey: ZodOptional<ZodString>;
+          forwardAuth: ZodDefault<ZodOptional<ZodBoolean>>;
+        }, $strict>>;
+        maxRedirects: ZodDefault<ZodOptional<ZodNumber>>;
+        followRedirects: ZodDefault<ZodOptional<ZodBoolean>>;
+        customErrors: ZodOptional<ZodArray<ZodObject<{
+          receivedStatus: ZodNumber;
+          targetStatus: ZodNumber;
+          message: ZodOptional<ZodString>;
+          condition: ZodOptional<ZodString>;
+        }, $strict>>>;
+        args: ZodOptional<ZodArray<ZodObject<{
+          name: ZodString;
+          value: ZodUnknown;
+          in: ZodEnum<{
             query: "query";
             body: "body";
             headers: "headers";
           }>;
-          spread: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-          arrayFormat: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+          spread: ZodOptional<ZodBoolean>;
+          condition: ZodOptional<ZodString>;
+          arrayFormat: ZodOptional<ZodEnum<{
             repeat: "repeat";
             brackets: "brackets";
             comma: "comma";
             stringify: "stringify";
           }>>;
-        }, zod_v4_core0.$strict>>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodOptional<zod_v40.ZodObject<{
-        data: zod_v40.ZodOptional<zod_v40.ZodUnion<readonly [zod_v40.ZodString, zod_v40.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>]>>;
-        raw: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        statusCode: zod_v40.ZodNumber;
-        message: zod_v40.ZodOptional<zod_v40.ZodString>;
-        headers: zod_v40.ZodOptional<zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodString>>;
-        contentDisposition: zod_v40.ZodOptional<zod_v40.ZodString>;
-        fileMetadata: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          contentType: zod_v40.ZodOptional<zod_v40.ZodString>;
-          contentLength: zod_v40.ZodOptional<zod_v40.ZodNumber>;
-          fileName: zod_v40.ZodOptional<zod_v40.ZodString>;
-          lastModified: zod_v40.ZodOptional<zod_v40.ZodString>;
-          etag: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>;
-        finalUrl: zod_v40.ZodOptional<zod_v40.ZodString>;
-      }, zod_v4_core0.$strict>>;
+        }, $strict>>>;
+      }, $strip>;
+      outputSchema: ZodOptional<ZodObject<{
+        data: ZodOptional<ZodUnion<readonly [ZodString, ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>]>>;
+        raw: ZodOptional<ZodUnknown>;
+        statusCode: ZodNumber;
+        message: ZodOptional<ZodString>;
+        headers: ZodOptional<ZodRecord<ZodString, ZodString>>;
+        contentDisposition: ZodOptional<ZodString>;
+        fileMetadata: ZodOptional<ZodObject<{
+          contentType: ZodOptional<ZodString>;
+          contentLength: ZodOptional<ZodNumber>;
+          fileName: ZodOptional<ZodString>;
+          lastModified: ZodOptional<ZodString>;
+          etag: ZodOptional<ZodString>;
+        }, $strict>>;
+        finalUrl: ZodOptional<ZodString>;
+      }, $strict>>;
     };
   };
   emit_event: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        event: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          eventType: zod_v40.ZodString;
-          eventId: zod_v40.ZodOptional<zod_v40.ZodString>;
-          eventDate: zod_v40.ZodOptional<zod_v40.ZodString>;
-          data: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        }, zod_v4_core0.$strip>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodUnknown>;
+      inputSchema: ZodObject<{
+        event: ZodOptional<ZodObject<{
+          eventType: ZodString;
+          eventId: ZodOptional<ZodString>;
+          eventDate: ZodOptional<ZodString>;
+          data: ZodOptional<ZodUnknown>;
+        }, $strip>>;
+      }, $strip>;
+      outputSchema: ZodRecord<ZodString, ZodUnknown>;
     };
   };
   browser_use: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        startUrl: zod_v40.ZodString;
-        systemPrompt: zod_v40.ZodOptional<zod_v40.ZodString>;
-        viewport: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          width: zod_v40.ZodNumber;
-          height: zod_v40.ZodNumber;
-        }, zod_v4_core0.$strict>>;
-        locale: zod_v40.ZodOptional<zod_v40.ZodString>;
-        budgets: zod_v40.ZodObject<{
-          maxDurationMs: zod_v40.ZodNumber;
-          maxSteps: zod_v40.ZodNumber;
-        }, zod_v4_core0.$strict>;
-        auth: zod_v40.ZodOptional<zod_v40.ZodObject<{
-          sensitiveKeys: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodString>>;
-          requiresSession: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
-          allowedDomains: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodString>>;
-        }, zod_v4_core0.$strict>>;
-      }, zod_v4_core0.$strip>;
-      outputSchema: zod_v40.ZodUnknown;
+      inputSchema: ZodObject<{
+        startUrl: ZodString;
+        systemPrompt: ZodOptional<ZodString>;
+        viewport: ZodOptional<ZodObject<{
+          width: ZodNumber;
+          height: ZodNumber;
+        }, $strict>>;
+        locale: ZodOptional<ZodString>;
+        budgets: ZodObject<{
+          maxDurationMs: ZodNumber;
+          maxSteps: ZodNumber;
+        }, $strict>;
+        auth: ZodOptional<ZodObject<{
+          sensitiveKeys: ZodOptional<ZodArray<ZodString>>;
+          requiresSession: ZodOptional<ZodBoolean>;
+          allowedDomains: ZodOptional<ZodArray<ZodString>>;
+        }, $strict>>;
+      }, $strip>;
+      outputSchema: ZodUnknown;
     };
   };
   code_execution_lambda: {
@@ -1873,45 +2612,45 @@ declare const stepFunctions: {
         block: Readonly<Block>;
         params?: StepFunctionParams;
       }, invoker?: LambdaInvoker) => Promise<StepFunctionOutput>;
-      inputSchema: zod_v40.ZodObject<{
-        lambdaName: zod_v40.ZodString;
-        region: zod_v40.ZodOptional<zod_v40.ZodString>;
-        endpoint: zod_v40.ZodOptional<zod_v40.ZodString>;
-        invocationType: zod_v40.ZodOptional<zod_v40.ZodEnum<{
+      inputSchema: ZodObject<{
+        lambdaName: ZodString;
+        region: ZodOptional<ZodString>;
+        endpoint: ZodOptional<ZodString>;
+        invocationType: ZodOptional<ZodEnum<{
           RequestResponse: "RequestResponse";
           Event: "Event";
           DryRun: "DryRun";
         }>>;
-        qualifier: zod_v40.ZodOptional<zod_v40.ZodString>;
-        args: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodObject<{
-          name: zod_v40.ZodString;
-          value: zod_v40.ZodUnknown;
-          condition: zod_v40.ZodOptional<zod_v40.ZodString>;
-        }, zod_v4_core0.$strict>>>;
-        dataKey: zod_v40.ZodOptional<zod_v40.ZodString>;
-      }, zod_v4_core0.$strict>;
-      outputSchema: zod_v40.ZodOptional<zod_v40.ZodObject<{
-        data: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        raw: zod_v40.ZodOptional<zod_v40.ZodUnknown>;
-        statusCode: zod_v40.ZodNumber;
-        message: zod_v40.ZodOptional<zod_v40.ZodString>;
-        executedVersion: zod_v40.ZodOptional<zod_v40.ZodString>;
-      }, zod_v4_core0.$strict>>;
+        qualifier: ZodOptional<ZodString>;
+        args: ZodOptional<ZodArray<ZodObject<{
+          name: ZodString;
+          value: ZodUnknown;
+          condition: ZodOptional<ZodString>;
+        }, $strict>>>;
+        dataKey: ZodOptional<ZodString>;
+      }, $strict>;
+      outputSchema: ZodOptional<ZodObject<{
+        data: ZodOptional<ZodUnknown>;
+        raw: ZodOptional<ZodUnknown>;
+        statusCode: ZodNumber;
+        message: ZodOptional<ZodString>;
+        executedVersion: ZodOptional<ZodString>;
+      }, $strict>>;
     };
   };
   sign_jwt: {
     v1: {
       fn: StepFunction;
-      inputSchema: zod_v40.ZodObject<{
-        algorithm: zod_v40.ZodLiteral<"RS256">;
-        privateKey: zod_v40.ZodString;
-        claims: zod_v40.ZodRecord<zod_v40.ZodString, zod_v40.ZodUnion<readonly [zod_v40.ZodString, zod_v40.ZodNumber]>>;
-      }, zod_v4_core0.$strict>;
-      outputSchema: zod_v40.ZodObject<{
-        token: zod_v40.ZodString;
-        expiresIn: zod_v40.ZodNumber;
-        publicKeyFingerprint: zod_v40.ZodString;
-      }, zod_v4_core0.$strict>;
+      inputSchema: ZodObject<{
+        algorithm: ZodLiteral<"RS256">;
+        privateKey: ZodString;
+        claims: ZodRecord<ZodString, ZodUnion<readonly [ZodString, ZodNumber]>>;
+      }, $strict>;
+      outputSchema: ZodObject<{
+        token: ZodString;
+        expiresIn: ZodNumber;
+        publicKeyFingerprint: ZodString;
+      }, $strict>;
     };
   };
 };
@@ -2737,4 +3476,4 @@ type Account = {
   originOwnerName?: string;
 };
 //#endregion
-export { AUTHORIZATION_SCHEMA, type Account, type Action, type ActionExample, type ActionResponse, type ActionType, type ActionValidationRule, type Assets, AuthType, type Authentication, type AuthenticationConfig, type AuthenticationField, type AuthenticationGuides, type AuthenticationNotice, BROWSER_USE_INPUT_PARAMS, BROWSER_USE_OUTPUT, type BaseIncrementalConfig, type BasePaginationConfig, type Block, type BlockContext, type BlockIndexedRecord, COMPOSITE_ID_LATEST_VERSION, type Category, type Checkpoint, type CompositeIdentifier, type CompositeIdentifierConfig, type CompositeIdentifierConnectorConfig, type Connector, type ConnectorDocumentation, type ConnectorEvents, CoreError, type Cursor, type CursorPaginationConfig, type DataSyncConfig, type DefenderMetadata, type DefenderSettings, type DeltaTokenIncrementalConfig, type DocumentationReference, type EnumOneOf, type EventRouter, type EventRouterRule, type EventToEmit, type ExecutionMode, ExecutionModes, type ExpressionContextOptions, type FieldConfig, type FlowType, type ForeachStep, type Guide, type GuideImage, type GuideSection, type GuideStep, INPUT_ENUM_REGISTRY, type IncrementalConfig, type Input, type InputFormat, type InputLocation, type InputRules, type IntermediateStepSnapshot, type IteratorLocation, type MatchedEventAction, type OffsetPaginationConfig, type PagePaginationConfig, type PaginationConfig, type ReleaseStage, ReleaseStages, type Schema, type SchemaField, type ScopeDefinition, type Settings, type SimpleStep, type Source, SourceType, type Step, type StepFunction, type StepFunctionMeta, StepFunctionName, type StepFunctionOutput, type StepFunctionParams, StepFunctionsFactory, stepFunctions as StepFunctionsRegistry, type StepsSnapshots, type StreamOutputData, StreamType, type SupportConfig, type SyncParams, type TestActionConfig, type TimeFilterIncrementalConfig, TransportType, type WebhookSetup, type WebhookSetupPhase, type WebhookSetupPhaseKind, areCursorsEqual, buildExpressionContext, decodeCompositeId, encodeCompositeId, evaluateEventRouter, evaluateExternalAccountIdExtractor, expandCursor, getCategoryDetails, getInputEnumValues, getIteratorLocation, getPaginationKeys, isCompositeId, isCoreError, isCursorEmpty, isForeachStep, isValidCategory, isValidEnumRef, minifyCursor, stripPaginationParams, updateCursor };
+export { AUTHORIZATION_SCHEMA, type Account, type Action, type ActionExample, type ActionResponse, type ActionType, type ActionValidationRule, type Assets, AuthType, type Authentication, type AuthenticationConfig, type AuthenticationField, type AuthenticationGuides, type AuthenticationNotice, BROWSER_USE_INPUT_PARAMS, BROWSER_USE_OUTPUT, type BaseIncrementalConfig, type BasePaginationConfig, type Block, type BlockContext, type BlockIndexedRecord, COMPOSITE_ID_LATEST_VERSION, type Category, type Checkpoint, type CompositeIdentifier, type CompositeIdentifierConfig, type CompositeIdentifierConnectorConfig, type Connector, type ConnectorDocumentation, type ConnectorEvents, CoreError, type Cursor, type CursorPaginationConfig, type DataSyncConfig, type DefenderMetadata, type DefenderSettings, type DeltaTokenIncrementalConfig, type DocumentationReference, type EnumOneOf, type EventRouter, type EventRouterRule, type EventToEmit, type ExecutionMode, ExecutionModes, type ExpressionContextOptions, type FieldConfig, type FlowType, type ForeachStep, type Guide, type GuideImage, type GuideSection, type GuideStep, INPUT_ENUM_REGISTRY, type IncrementalConfig, type Input, type InputFormat, type InputLocation, type InputRules, type IntermediateStepSnapshot, type IteratorLocation, type MatchedEventAction, type OffsetPaginationConfig, type PagePaginationConfig, type PaginationConfig, type ReleaseStage, ReleaseStages, type Schema, type SchemaField, type ScopeDefinition, type Settings, type SimpleStep, type Source, SourceType, type Step, type StepFunction, type StepFunctionMeta, StepFunctionName, type StepFunctionOutput, type StepFunctionParams, StepFunctionsFactory, stepFunctions as StepFunctionsRegistry, type StepsSnapshots, type StreamOutputData, StreamType, type SupportConfig, type SyncParams, type TestActionConfig, type TimeFilterIncrementalConfig, TransportType, type WebhookSetup, type WebhookSetupPhase, type WebhookSetupPhaseKind, areCursorsEqual, buildExpressionContext, decodeCompositeId, encodeCompositeId, evaluateEventRouter, evaluateExternalAccountIdExtractor, expandCursor, getCategoryDetails, getInputEnumValues, getIteratorLocation, getPaginationKeys, isCompositeId, isCoreError, isCursorEmpty, isForeachStep, isValidCategory, isValidEnumRef, minifyCursor, stripIncrementalParams, stripPaginationParams, updateCursor };