#!/usr/bin/env node
import * as Context from "effect/Context";
import * as Effect$1 from "effect/Effect";
import { Effect, Yieldable } from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Stream from "effect/Stream";
import * as S from "effect/Schema";
import { Pipeable } from "effect/Pipeable";
import "effect/Config";
import { Scope } from "effect/Scope";
import { HttpBodyError } from "effect/unstable/http/HttpBody";
import { HttpServerError } from "effect/unstable/http/HttpServerError";
import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
import "effect/FileSystem";
import "effect/Path";

//#region src/Util/data.d.ts
type Primitive = never | undefined | null | boolean | number | string | bigint | symbol;
//#endregion
//#region src/Http.d.ts
type HttpEffect<Req$1 = never> = Effect$1.Effect<HttpServerResponse.HttpServerResponse, HttpServerError | HttpBodyError, HttpServerRequest | Scope | Req$1>;
//#endregion
//#region src/ExecutionContext.d.ts
interface BaseExecutionContext {
  Type: string;
  id: string;
  env: Record<string, any>;
  get<T>(key: string): Effect$1.Effect<T>;
  set(id: string, output: Output): Effect$1.Effect<string>;
  exports?: Effect$1.Effect<Record<string, any>>;
  serve?<Req$1 = never>(handler: HttpEffect<Req$1>): Effect$1.Effect<void, never, Req$1>;
}
interface ExecutionContext<Ctx extends BaseExecutionContext = BaseExecutionContext> extends Context.Service<`ExecutionContext<${Ctx["Type"]}>`, Ctx> {}
declare const ExecutionContext: ExecutionContext<BaseExecutionContext> & (<Ctx extends BaseExecutionContext>(type: Ctx["Type"]) => ExecutionContext<Ctx>);
//#endregion
//#region src/Namespace.d.ts
interface NamespaceNode {
  Id: string;
  Parent?: NamespaceNode;
}
//#endregion
//#region src/RemovalPolicy.d.ts
declare const RemovalPolicy_base: any;
declare class RemovalPolicy extends RemovalPolicy_base {}
//#endregion
//#region src/Resource.d.ts
type LogicalId = string;
interface ResourceBinding<Data = any> {
  sid: string;
  data: Data;
}
interface ResourceLike<Type extends string = string, Props$2 extends object | undefined = any, Attributes$1 extends object = object, Binding = any> {
  /**
   * Namespace containing this Resource.
   */
  Namespace: NamespaceNode | undefined;
  /**
   * Fully Qualified Name (namespace path + logical ID).
   * Used as the unique key for state storage.
   */
  FQN: string;
  /**
   * Type of the Resource (e.g. AWS.Lambda.Function)
   */
  Type: Type;
  /**
   * Logical ID of the Resource (e.g. MyFunction)
   */
  LogicalId: LogicalId;
  /**
   * Properties of the Resource.
   */
  Props: Props$2;
  /**
   * Removal Policy of the Resource.
   */
  RemovalPolicy: RemovalPolicy["Service"];
  /** @internal phantom */
  Attributes: Attributes$1;
  /** @internal phantom */
  Binding: Binding;
}
//#endregion
//#region src/State/ResourceState.d.ts
type ResourceState = CreatingResourceState | CreatedResourceState | UpdatingReourceState | UpdatedResourceState | DeletingResourceState | ReplacingResourceState | ReplacedResourceState;
type Props$1 = Record<string, any>;
type Attr = Record<string, any>;
type ResourceStatus = ResourceState["status"];
type ReplacementResourceState = ReplacingResourceState | ReplacedResourceState;
type ReplacementOldResourceState = CreatingResourceState | CreatedResourceState | UpdatingReourceState | UpdatedResourceState | DeletingResourceState | ReplacementResourceState;
interface BaseResourceState {
  /** Type of the Resource (e.g. AWS.Lambda.Function) */
  resourceType: string;
  /** Namespace of the Resource */
  namespace: NamespaceNode | undefined;
  /** Fully Qualified Name (namespace path + logical ID) */
  fqn: string;
  /** Logical ID of the Resource (stable across creates, updates, deletes and replaces) */
  logicalId: string;
  /** A unique randomly generated token used to seed ID generation (only changes when replaced) */
  instanceId: string;
  /** The version of the provider that was used to create/update the resource. */
  providerVersion: number;
  /** Current status of the logical Resource */
  status: ResourceStatus;
  /** List of FQNs of resources that depend on this resource */
  downstream: string[];
  /** List of Bindings attached to this Resource */
  bindings: ResourceBinding[];
  /** Desired state (input props) of this Resource */
  props?: Props$1;
  /** The output attributes of this Resource (if it has been created) */
  attr?: Attr;
  /** The removal policy of the resource */
  removalPolicy?: RemovalPolicy["Service"];
}
interface CreatingResourceState extends BaseResourceState {
  status: "creating";
  /** The new resource properties that are being (or have been) applied. */
  props: Props$1;
}
interface CreatedResourceState extends BaseResourceState {
  status: "created";
  /** The new resource properties that have been applied. */
  props: Props$1;
  /** The output attributes of the created resource */
  attr: Attr;
}
interface UpdatingReourceState extends BaseResourceState {
  status: "updating";
  /** The new resource properties that are being (or have been) applied. */
  props: Props$1;
  old: {
    /** The old resource properties that have been successfully applied. */
    props: Props$1;
    /** List of Bindings attached to this Resource */
    bindings: any[];
    /** The old output properties that have been successfully applied. */
    attr: Attr;
  };
}
interface UpdatedResourceState extends BaseResourceState {
  status: "updated";
  /** The new resource properties that are being (or have been) applied. */
  props: Props$1;
  /** The output attributes of the created resource */
  attr: Attr;
}
interface DeletingResourceState extends BaseResourceState {
  status: "deleting";
  /** Attributes of the resource being deleted */
  attr: Attr | undefined;
}
interface ReplacingResourceState extends BaseResourceState {
  status: "replacing";
  /** Desired properties of the new resource (the replacement) */
  props: Props$1;
  /** Reference to the state of the old resource (the one being replaced) */
  old: ReplacementOldResourceState;
  /** Whether the resource should be deleted before or after replacements */
  deleteFirst: boolean;
}
interface ReplacedResourceState extends BaseResourceState {
  status: "replaced";
  /** Desired properties of the new resource (the replacement) */
  props: Props$1;
  /** Output attributes of the new resource (the replacement) */
  attr: Attr;
  /** Reference to the state of the old resource (the one being replaced) */
  old: ReplacementOldResourceState;
  /** Whether the resource should be deleted before or after replacements */
  deleteFirst: boolean;
}
//#endregion
//#region src/Output.d.ts
interface Output<A = any, Req$1 = any> extends Pipeable {
  /** @internal phantom */
  readonly kind: string;
  /** @internal phantom */
  readonly A: A;
  /** @internal phantom */
  readonly req: Req$1;
  /** @internal phantom */
  [Symbol.iterator](): Iterator<Yieldable<any, void, never, Req$1>, Accessor<A>, void>;
  bind(id: string): Effect$1.Effect<Effect$1.Effect<A>, never, ExecutionContext>;
  asEffect(): Effect$1.Effect<Accessor<A>, never, Req$1>;
  as<T>(): Output<T, Req$1>;
}
interface Accessor<A> extends Effect$1.Effect<A> {}
//#endregion
//#region src/Input.d.ts
type Function = (...args: any[]) => any;
type Constructor = new (...args: any[]) => any;
type PolicyLike = {
  kind: "alchemy/Policy";
};
type Input<T> = T | Output<T> | Effect<T, any, any> | (T extends S.Schema<any> ? never : Output<T, any> | (T extends Primitive ? never : T extends any[] ? number extends T["length"] ? Input<T[number]>[] : Inputs<T> : T extends object ? { [K in keyof T]: Input<T[K]> } : never));
declare namespace Input {
  type Resolve<T> = T extends {
    Type: string;
    Attributes: infer Attributes;
  } ? { [K in keyof Attributes]: Resolve<Attributes[K]> } : T extends Output<infer U> ? U : T extends Primitive | Constructor | Function | S.Schema<any> | PolicyLike ? T : T extends any[] ? ResolveArray<T> : T extends Record<string, any> ? { [k in keyof T]: Input.Resolve<T[k]> } : never;
  type ResolveArray<T extends any[]> = number extends T["length"] ? Resolve<T[number]>[] : ResolveTuple<T>;
  type ResolveTuple<T extends any[], Accum extends any[] = []> = T extends [infer H, ...infer Tail] ? ResolveTuple<Tail, [...Accum, Input.Resolve<H>]> : Accum;
  type ResolveProps<Props$2 extends Record<string, any>> = { [k in keyof Props$2]: Input.Resolve<Props$2[k]> };
  type ResolveOpaque<T> = true extends IsOut<T> ? ResolveOut<T> : Resolve<T>;
  type IsOut<T> = T extends Output<infer _U> ? true : never;
  type ResolveOut<T> = T extends Output<infer U> ? U : never;
}
type Inputs<T extends any[], Out extends any[] = []> = T extends [infer H, ...infer T] ? Inputs<T, [...Out, Input<H>]> : Out;
//#endregion
//#region src/Diff.d.ts
type Diff = NoopDiff | UpdateDiff | ReplaceDiff;
interface NoopDiff {
  action: "noop";
  stables?: undefined;
}
interface UpdateDiff {
  action: "update";
  /** properties that won't change as part of this update */
  stables?: string[];
}
interface ReplaceDiff {
  action: "replace";
  deleteFirst?: boolean;
  stables?: undefined;
}
//#endregion
//#region src/Provider.d.ts
type BindingData<Res extends ResourceLike> = [Res] extends [{
  Binding: infer B;
}] ? ResourceBinding<B>[] : any[];
type Props<Res extends ResourceLike> = keyof Res["Props"] extends never ? Res["Props"] | undefined : Res["Props"];
interface LogLine {
  timestamp: Date;
  message: string;
}
interface LogsInput {
  since?: Date;
  limit?: number;
}
interface ProviderService<Res extends ResourceLike = ResourceLike, ReadReq = never, DiffReq = never, PrecreateReq = never, CreateReq = never, UpdateReq = never, DeleteReq = never, TailReq = never, LogsReq = never> {
  /**
   * The version of the provider.
   *
   * @default 0
   */
  version?: number;
  /**
   * Returns a stream of log lines for a deployed resource.
   * Used by `alchemy tail` to stream real-time logs.
   */
  tail?(input: {
    id: string;
    instanceId: string;
    props: Props<Res>;
    output: Res["Attributes"];
  }): Stream.Stream<LogLine, any, TailReq>;
  /**
   * Queries historical logs for a deployed resource.
   * Used by `alchemy logs` to fetch past log entries.
   */
  logs?(input: {
    id: string;
    instanceId: string;
    props: Props<Res>;
    output: Res["Attributes"];
    options: LogsInput;
  }): Effect$1.Effect<LogLine[], any, LogsReq>;
  read?(input: {
    id: string;
    instanceId: string;
    olds: Props<Res>;
    output: Res["Attributes"] | undefined;
  }): Effect$1.Effect<Res["Attributes"] | undefined, any, ReadReq>;
  /**
   * Properties that are always stable across any update.
   */
  stables?: Extract<keyof Res["Attributes"], string>[];
  diff?(input: {
    id: string;
    instanceId: string;
    olds: Props<Res>;
    news: Input<Props<Res>>;
    oldBindings: BindingData<Res>;
    newBindings: Input<BindingData<Res>>;
    output: Res["Attributes"] | undefined;
  }): Effect$1.Effect<Diff | void, any, DiffReq>;
  precreate?(input: {
    id: string;
    news: Props<Res>;
    instanceId: string;
    session: ScopedPlanStatusSession;
    bindings: BindingData<Res>;
  }): Effect$1.Effect<Res["Attributes"], any, PrecreateReq>;
  create(input: {
    id: string;
    instanceId: string;
    news: Props<Res>;
    session: ScopedPlanStatusSession;
    bindings: BindingData<Res>;
    output?: Res["Attributes"];
  }): Effect$1.Effect<Res["Attributes"], any, CreateReq>;
  update(input: {
    id: string;
    instanceId: string;
    news: Props<Res>;
    olds: Props<Res>;
    output: Res["Attributes"];
    session: ScopedPlanStatusSession;
    bindings: BindingData<Res>;
  }): Effect$1.Effect<Res["Attributes"], any, UpdateReq>;
  delete(input: {
    id: string;
    instanceId: string;
    olds: Props<Res>;
    output: Res["Attributes"];
    session: ScopedPlanStatusSession;
    bindings: BindingData<Res>;
  }): Effect$1.Effect<void, any, DeleteReq>;
}
//#endregion
//#region src/Plan.d.ts
type Apply<R extends ResourceLike = ResourceLike> = Create<R> | Update<R> | Replace<R> | NoopUpdate<R>;
type BindingAction = "create" | "update" | "delete" | "noop";
interface BindingNode<Data = any> extends ResourceBinding {
  action: BindingAction;
  data: Data;
}
interface BaseNode<R extends ResourceLike<string> = ResourceLike<string>> {
  resource: R;
  provider: ProviderService<R>;
  downstream: string[];
  bindings: BindingNode<R["Binding"]>[];
}
interface Create<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
  action: "create";
  props: R["Props"];
  state: CreatingResourceState | undefined;
}
interface Update<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
  action: "update";
  props: R["Props"];
  state: CreatedResourceState | UpdatedResourceState | UpdatingReourceState | ReplacedResourceState;
}
interface Delete<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
  action: "delete";
  state: ResourceState;
}
interface NoopUpdate<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
  action: "noop";
  state: CreatedResourceState | UpdatedResourceState;
}
interface Replace<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
  action: "replace";
  props: any;
  deleteFirst: boolean;
  restart?: boolean;
  state: CreatingResourceState | CreatedResourceState | UpdatingReourceState | UpdatedResourceState | ReplacingResourceState | ReplacedResourceState;
}
type Plan<Output$1 = any> = {
  resources: { [id in string]: Apply<any> };
  deletions: { [id in string]?: Delete<ResourceLike> };
  output: Output$1;
};
//#endregion
//#region src/Cli/Event.d.ts
type ApplyStatus = "attaching" | "post-attach" | "pending" | "pre-creating" | "creating" | "creating replacement" | "created" | "updating" | "updated" | "deleting" | "deleted" | "replacing" | "replaced" | "fail";
type ApplyEvent = AnnotateEvent | StatusChangeEvent;
interface AnnotateEvent {
  kind: "annotate";
  id: string;
  message: string;
}
interface StatusChangeEvent {
  kind: "status-change";
  id: string;
  type: string;
  status: ApplyStatus;
  message?: string;
  bindingId?: string;
}
//#endregion
//#region src/Cli/Cli.d.ts
interface PlanStatusSession {
  emit: (event: ApplyEvent) => Effect$1.Effect<void>;
  done: () => Effect$1.Effect<void>;
}
interface ScopedPlanStatusSession extends PlanStatusSession {
  note: (note: string) => Effect$1.Effect<void>;
}
interface CLIService {
  approvePlan: <P$1 extends Plan>(plan: P$1) => Effect$1.Effect<boolean>;
  displayPlan: <P$1 extends Plan>(plan: P$1) => Effect$1.Effect<void>;
  startApplySession: <P$1 extends Plan>(plan: P$1) => Effect$1.Effect<PlanStatusSession>;
}
declare const Cli_base: any;
declare class Cli extends Cli_base {}
//#endregion
//#region src/Cli/InkCLI.d.ts
declare const inkCLI: () => Layer.Layer<unknown, never, never>;
//#endregion
export { CLIService, Cli, PlanStatusSession, ScopedPlanStatusSession, inkCLI };
//# sourceMappingURL=index.d.ts.map