import { a as CredentialInputs, p as Primitive, t as AnyCredentialSet, u as ResolvedCredentials } from "./CredentialSet-lUr_8nN3.mjs";
import { c as AnyZodSchema, d as InputSchema, f as InputSchemaOrUndefined, l as InferSchema, p as JsonObject, u as InferSchemaOrUndefined } from "./schemas-DXcT2SRm.mjs";
import { M as Duration } from "./index-BqY2HTnE.mjs";
import { z } from "zod";

//#region src/artifacts/common.d.ts
type SHA256Hash = string & {
  readonly __brand: 'SHA256Hash';
};
declare const RetryConfigSchema: z.ZodObject<{
  constant: z.ZodOptional<z.ZodObject<{
    attempts: z.ZodNumber;
    seconds: z.ZodNumber;
  }, z.core.$strip>>;
  exponential: z.ZodOptional<z.ZodObject<{
    attempts: z.ZodNumber;
    base: z.ZodOptional<z.ZodNumber>;
    multiplier: z.ZodOptional<z.ZodNumber>;
  }, z.core.$strip>>;
}, z.core.$strip>;
type RetryConfig = z.infer<typeof RetryConfigSchema>;
//#endregion
//#region src/operation/schemas.d.ts
declare const OperationManifestSchema: z.ZodObject<{
  description: z.ZodString;
  id: z.ZodString;
  name: z.ZodString;
  needsApproval: z.ZodOptional<z.ZodBoolean>;
  requiredOAuthScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
  retries: z.ZodOptional<z.ZodObject<{
    constant: z.ZodOptional<z.ZodObject<{
      attempts: z.ZodNumber;
      seconds: z.ZodNumber;
    }, z.core.$strip>>;
    exponential: z.ZodOptional<z.ZodObject<{
      attempts: z.ZodNumber;
      base: z.ZodOptional<z.ZodNumber>;
      multiplier: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
  timeout: z.ZodOptional<z.ZodType<Duration, unknown, z.core.$ZodTypeInternals<Duration, unknown>>>;
  maxDurationMs: z.ZodOptional<z.ZodNumber>;
  manifestVersion: z.ZodLiteral<1>;
  type: z.ZodLiteral<"operation">;
  credentialSets: z.ZodArray<z.ZodObject<{
    manifestVersion: z.ZodLiteral<1>;
    type: z.ZodLiteral<"credentialSet">;
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    auth: z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>;
    credentialType: z.ZodEnum<{
      oauth: "oauth";
      manual: "manual";
    }>;
    exposure: z.ZodOptional<z.ZodEnum<{
      "user-runtime": "user-runtime";
      "platform-only": "platform-only";
    }>>;
    proxy: z.ZodOptional<z.ZodObject<{
      hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
      hostPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
      injection: z.ZodOptional<z.ZodObject<{
        headers: z.ZodOptional<z.ZodBoolean>;
        basicAuth: z.ZodOptional<z.ZodBoolean>;
        queryParams: z.ZodOptional<z.ZodBoolean>;
        body: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    needsRawSecret: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>>;
  input: z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>;
  output: z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>;
  workflowGlobals: z.ZodOptional<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
}, z.core.$strip>;
type OperationManifest = z.infer<typeof OperationManifestSchema>;
//#endregion
//#region src/operation/types.d.ts
type OperationCredentials<TCredentialSets extends readonly AnyCredentialSet[] | undefined> = ResolvedCredentials<TCredentialSets>;
type OperationCredentialInputs<TCredentialSets extends readonly AnyCredentialSet[] | undefined> = CredentialInputs<TCredentialSets>;
type OperationRuntimeContext<TCredentials extends Record<string, unknown> = Record<string, never>, TWorkflowGlobals = undefined> = Readonly<{
  attempt?: number;
  credentials: Readonly<TCredentials>;
  maxAttempts?: number;
  stepId?: string;
  toolCallId?: string;
  traceparent?: string;
  tracestate?: string;
  workflowGlobals: TWorkflowGlobals;
}>;
type OperationResolvedContext<TCredentialSets extends readonly AnyCredentialSet[] | undefined, TWorkflowGlobalsSchema extends AnyZodSchema | undefined> = OperationRuntimeContext<OperationCredentials<TCredentialSets>, InferSchemaOrUndefined<TWorkflowGlobalsSchema>>;
type OperationRunContext<TCredentialSets extends readonly AnyCredentialSet[] | undefined, TWorkflowGlobalsSchema extends AnyZodSchema | undefined> = Readonly<{
  attempt?: number;
  credentials?: Readonly<Partial<OperationCredentialInputs<TCredentialSets>>>;
  maxAttempts?: number;
  stepId?: string;
  toolCallId?: string;
  traceparent?: string;
  tracestate?: string;
  workflowGlobals?: InputSchemaOrUndefined<TWorkflowGlobalsSchema>;
}>;
interface OperationConfig<TInputSchema extends AnyZodSchema, TOutputSchema extends AnyZodSchema, TCredentialSets extends readonly AnyCredentialSet[] = readonly [], TWorkflowGlobalsSchema extends AnyZodSchema | undefined = undefined> {
  /**
   * Credential sets the operation depends on at runtime. Uniqueness is enforced
   * at construction time via `assertUniqueCredentialSetIds` — duplicate raw ids
   * throw with a clear message. We avoid encoding uniqueness in the field type
   * because the deferred conditional (`AssertUniqueCredentialSetIds<...>`) does
   * not resolve when `TCredentialSets` is supplied through a generic factory,
   * and would force every wrapper to cast through `unknown`.
   */
  readonly credentialSets?: TCredentialSets;
  readonly description: string;
  readonly id: string;
  readonly input: TInputSchema;
  readonly name: string;
  readonly needsApproval?: boolean;
  readonly output: TOutputSchema;
  readonly requiredOAuthScopes?: readonly string[];
  readonly retries?: RetryConfig;
  readonly tags?: readonly string[];
  readonly timeout?: Duration;
  /**
   * Upper bound on the operation's expected duration, in milliseconds.
   *
   * Informs the platform's proactive OAuth refresh — when a step with
   * `maxDurationMs: 15 * 60_000` runs against a token expiring in 10
   * minutes, the credential coordinator refreshes before dispatch so the
   * step's own window has a valid token throughout.
   *
   * Omit for steps whose duration is unbounded by design (polling triggers,
   * human-in-the-loop) or trivially short (< 30s). Must be a positive
   * integer when set.
   *
   * @example new Step({ name: 'Upload large file', maxDurationMs: 15 * 60_000, ... })
   */
  readonly maxDurationMs?: number;
  readonly workflowGlobals?: TWorkflowGlobalsSchema;
  readonly run: (input: InferSchema<TInputSchema>, ctx: OperationResolvedContext<TCredentialSets, TWorkflowGlobalsSchema>) => Promise<InferSchema<TOutputSchema>>;
}
type OperationInput<T> = T extends Operation<infer TInputSchema, AnyZodSchema, readonly AnyCredentialSet[], AnyZodSchema | undefined> ? InputSchema<TInputSchema> : never;
type OperationOutput<T> = T extends Operation<AnyZodSchema, infer TOutputSchema, readonly AnyCredentialSet[], AnyZodSchema | undefined> ? InferSchema<TOutputSchema> : never;
type OperationContextFor<T> = T extends Operation<AnyZodSchema, AnyZodSchema, infer TCredentialSets, infer TGlobalsSchema> ? OperationResolvedContext<TCredentialSets, TGlobalsSchema> : never;
type AnyOperation = Operation<AnyZodSchema, AnyZodSchema, readonly AnyCredentialSet[], AnyZodSchema | undefined>;
//#endregion
//#region src/operation/Operation.d.ts
declare class Operation<TInputSchema extends AnyZodSchema, TOutputSchema extends AnyZodSchema, TCredentialSets extends readonly AnyCredentialSet[] = readonly [], TWorkflowGlobalsSchema extends AnyZodSchema | undefined = undefined> extends Primitive<OperationManifest> {
  #private;
  readonly kind: "operation";
  readonly credentialSets: TCredentialSets;
  readonly description: string;
  readonly id: string;
  readonly input: TInputSchema;
  readonly name: string;
  readonly needsApproval?: boolean;
  readonly output: TOutputSchema;
  readonly requiredOAuthScopes?: readonly string[];
  readonly retries?: RetryConfig;
  readonly tags: readonly string[];
  readonly timeout?: Duration;
  /**
   * Upper bound on the operation's expected duration, in milliseconds.
   * See {@link OperationConfig.maxDurationMs}.
   */
  readonly maxDurationMs?: number;
  readonly workflowGlobals?: TWorkflowGlobalsSchema;
  constructor(config: OperationConfig<TInputSchema, TOutputSchema, TCredentialSets, TWorkflowGlobalsSchema>);
  withTimeout(duration: Duration): Operation<TInputSchema, TOutputSchema, TCredentialSets, TWorkflowGlobalsSchema>;
  retry(policy: RetryConfig): Operation<TInputSchema, TOutputSchema, TCredentialSets, TWorkflowGlobalsSchema>;
  configure(config: Readonly<{
    description?: string;
    timeout?: Duration;
    retries?: RetryConfig;
    tags?: readonly string[];
    needsApproval?: boolean;
  }>): Operation<TInputSchema, TOutputSchema, TCredentialSets, TWorkflowGlobalsSchema>;
  getCredentialRequirements(): {
    credentialSetId: string;
    credentialType: "oauth" | "manual";
    credentialKeys: string[];
    optionalCredentialKeys?: string[] | undefined;
    storedCredentialKeys?: string[] | undefined;
    optionalStoredCredentialKeys?: string[] | undefined;
    schemaFingerprint?: string | undefined;
    needsDynamicResolution?: boolean | undefined;
    dynamicResolutionCacheMs?: number | undefined;
    onCredentialRevoked?: "fail" | "retry-once" | undefined;
    proxy?: {
      hosts?: string[] | undefined;
      hostPatterns?: string[] | undefined;
      injection?: {
        headers?: boolean | undefined;
        basicAuth?: boolean | undefined;
        queryParams?: boolean | undefined;
        body?: boolean | undefined;
      } | undefined;
    } | undefined;
    needsRawSecret?: boolean | undefined;
    requiredOAuthScopes?: string[] | undefined;
  }[];
  /** @internal Used by the flow graph builder for nesting detection. */
  getRunFunctionSource(): string;
  mapInput<TNewInputSchema extends AnyZodSchema>(schema: TNewInputSchema, fn: (input: InferSchema<TNewInputSchema>) => InferSchema<TInputSchema>): Operation<TNewInputSchema, TOutputSchema, TCredentialSets, TWorkflowGlobalsSchema>;
  mapOutput<TNewOutputSchema extends AnyZodSchema>(schema: TNewOutputSchema, fn: (output: InferSchema<TOutputSchema>) => InferSchema<TNewOutputSchema>): Operation<TInputSchema, TNewOutputSchema, TCredentialSets, TWorkflowGlobalsSchema>;
  run(input: z.input<TInputSchema>, ctx?: OperationRunContext<TCredentialSets, TWorkflowGlobalsSchema>): Promise<z.output<TOutputSchema>>;
  /**
   * Execute the step implementation directly, bypassing interceptors and
   * runtime checks. Used by the inline step execution runtime to avoid
   * recursion through handleStep.
   * @internal
   */
  executeDirectly(input: z.input<TInputSchema>, ctx: OperationRunContext<TCredentialSets, TWorkflowGlobalsSchema>): Promise<z.output<TOutputSchema>>;
  toManifest(): OperationManifest;
}
//#endregion
export { OperationCredentialInputs as a, OperationOutput as c, OperationRuntimeContext as d, RetryConfig as f, OperationContextFor as i, OperationResolvedContext as l, SHA256Hash as m, AnyOperation as n, OperationCredentials as o, RetryConfigSchema as p, OperationConfig as r, OperationInput as s, Operation as t, OperationRunContext as u };