@stackone/core 2.76.0 → 3.0.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 = {
@@ -994,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;
@@ -1030,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: {
@@ -1039,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";
@@ -1050,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: {
@@ -1069,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";
@@ -1083,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: {
@@ -1876,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>;
     };
   };
 };