export interface ExternalOperationValue {
  readonly _tag: "Operation"
  readonly annotations: ReadonlyArray<Annotation>
}

type HttpGroupReference = HttpGroupValue | (abstract new (...args: never[]) => object)

export interface HttpGroupValue {
  readonly _tag: "HttpGroup"
  readonly annotations: ReadonlyArray<Annotation>
}

declare const Model: { persistent: <S extends Schema.Top>(schema: S, options: PersistentModelOptions) => ModelValue<S> }

export interface ModelValue<S extends Schema.Top> {
  readonly _tag: "Model"
  readonly annotations: ReadonlyArray<Annotation>
  readonly schema: S
}

import { Operation, Reflect } from "@effx/runtime"
import { Schema } from "effect"
import assert from "node:assert"

const GetUser = Operation.query({
  name: "User.Get",
  input: Schema.Struct({ id: Schema.String }),
  success: Schema.Struct({ id: Schema.String })
})
  .http.get("/users/:id")
  .declare()

assert.deepStrictEqual(
  GetUser.annotations.map((a) => a.name),
  ["Query", "Http.Get"]
)
assert.strictEqual(typeof Reflect.annotationsOf, "function")

declare const Operation: {
  query: (
    args_0: Readonly<{ readonly input: Schema.Top; readonly success: Schema.Top; readonly name?: string | undefined }>
  ) => OperationBuilder
  command: (
    args_0: Readonly<{ readonly input: Schema.Top; readonly success: Schema.Top; readonly name?: string | undefined }>
  ) => OperationBuilder
}

declare class OperationBuilder { constructor(readonly annotations: ReadonlyArray<Annotation>) }

declare const append: (annotation: Annotation) => OperationBuilder

declare const with: (applied: Applied<string, "operation">) => OperationBuilder

declare const annotate: (name: string, ...args: Annotation["args"]) => OperationBuilder

declare const in: (args_0: HttpGroupReference) => OperationBuilder

declare const rpc: (args_0: string) => OperationBuilder

declare const cli: (args_0: string) => OperationBuilder

declare const authorize: (args_0: Capability) => OperationBuilder

declare const errors: (...args: Parameters<typeof Builtins.Errors>) => OperationBuilder

declare const requirements: (...args: Parameters<typeof Builtins.Requirements>) => OperationBuilder

declare const handler: <Handler>(handler: Handler) => OperationValue<Handler>

declare const declare: () => ExternalOperationValue

readonly http: { access: (args_0: Readonly<{ readonly capabilities: TaggedLive<{ readonly None: {}; readonly One: { readonly capability: Arg<string, string>; }; readonly Any: { readonly capabilities: Arg<readonly [string, ...string[]], readonly [string, ...string[]]>; }; readonly All: { readonly capabilities: Arg<readonly [string, ...string[]], readonly [string, ...string[]]>; }; }>; readonly requirements: ReadonlyArray<Readonly<{ readonly id: string; readonly parameters?: { readonly [key: string]: JsonValue; } | undefined; }>>; readonly canonicalScopeResolver: object; readonly annotator?: ((spec: HttpAccessAnnotationSpec) => Context<never>) | undefined; readonly exposure?: "External" | "Internal" | undefined; readonly acceptedCredentials?: readonly [string, ...string[]] | undefined; readonly principalKinds?: readonly ["Anonymous" | "Person" | "ServicePrincipal" | "CapabilityHolder", ...("Anonymous" | "Person" | "ServicePrincipal" | "CapabilityHolder")[]] | undefined; readonly concealment?: TaggedLive<{ readonly Reveal: {}; readonly NotFound: { readonly stages: Arg<readonly [string, ...string[]], readonly [string, ...string[]]>; }; }> | undefined; readonly decisionTime?: "SnapshotRead" | "Transaction" | undefined; readonly snapshotDecisionForCommand?: boolean | undefined; }>) => OperationBuilder; contract: (args_0: Readonly<{ readonly root?: string | undefined; readonly group?: string | undefined; readonly params?: Schema.Top | undefined; readonly query?: true | Schema.Top | undefined; readonly headers?: Schema.Top | undefined; readonly payload?: Schema.Top | undefined; readonly payloadIsQuery?: boolean | undefined; readonly success?: Schema.Top | undefined; readonly status?: number | undefined; readonly mediaType?: string | undefined; readonly responseHeaders?: Schema.Top | undefined; readonly conditional?: boolean | undefined; readonly middleware?: ReadonlyArray<ServiceLike> | undefined; readonly metadata?: Readonly<{ readonly annotator?: HttpOperationAnnotator | undefined; readonly operationId?: string | undefined; readonly summary?: string | undefined; readonly description?: string | undefined; readonly tags?: ReadonlyArray<string> | undefined; readonly commandIdentity?: ExportedFunctionSymbol | undefined; }> | undefined; }>) => OperationBuilder; problems: <Code extends string>(options: HttpProblemsOptions<Code>) => OperationBuilder; get: (args_0: string) => OperationBuilder; post: (args_0: string) => OperationBuilder; put: (args_0: string) => OperationBuilder; patch: (args_0: string) => OperationBuilder; delete: (args_0: string) => OperationBuilder; }

readonly foldkit: { command: (args_0: Readonly<{ readonly success: Schema.Top; readonly failure: Schema.Top; }>) => OperationBuilder; }

export interface OperationValue<Handler> {
  readonly _tag: "Operation"
  readonly annotations: ReadonlyArray<Annotation>
  readonly handler: Handler
}

declare const group: (options: HttpGroupOptions) => HttpGroupValue

declare const problems: <Code extends string>(
  options: HttpProblemsOptions<Code>
) => Applied<typeof Builtins.HttpProblems.name, "operation">