export const agentClientRpcMethods = [
  ...identityRpcMethods,
  ...networkRpcMethods,
  ...nonTmAuthorityTaskRpcMethods,
  ...appRpcMethods,
] as const

export type AnyAgentClientRpcDefinition =
  (typeof agentClientRpcMethods)[number] & RpcDefinition<string, any, any>;

export type AnyNotificationDefinition =
  (typeof notificationDefinitions)[number];

export type AnyServerRpcDefinition = (typeof serverRpcMethods)[number] &

export type AnyTaskCallbackRpcDefinition = (typeof taskCallbackMethods)[number];

export type AnyTaskMasterRpcDefinition = (typeof taskMasterRpcMethods)[number] &

export function brandedId<const BrandName extends string>(brand: BrandName)

export function brandedNumber<const BrandName extends string>(
  brand: BrandName,
  options: Parameters<typeof Type.Number>[0] = {},
)

export type BrandedNumber<BrandName extends string> = number &

export function brandedString<const BrandName extends string>(
  brand: BrandName,
  options: Parameters<typeof Type.String>[0] = {},
)

export type BrandedString<BrandName extends string> = string &

export function checkProtocolRange(
  params: { readonly minProtocol: string; readonly maxProtocol: string },
  serverVersion: string,
): Effect.Effect<void, ProtocolMismatchError | InvalidProtocolVersionError>

export function compareProtocolVersion(a: string, b: string): -1 | 0 | 1

export type DateTimeString = Static<typeof DateTimeStringSchema>;

export function dateTimeStringSchema(): typeof DateTimeStringSchema

export function decodeClientInbound(
  parsed: unknown,
): Effect.Effect<DecodedClientInbound, MalformedFrameError>

export type DecodedClientInbound =
  | ({
      readonly _tag: "ClientRequest";
    } & DecodedRpcRequest<AnyServerRpcDefinition>)

export class DecodedResponseError extends Data.TaggedClass("ResponseError")<{
  readonly frame: ResponseFrame;
  readonly id: JsonRpcId;
  readonly error: Extract<ResponseFrame, { error: unknown }>["error"];
}> {}

export class DecodedResponseSuccess extends Data.TaggedClass(
  "ResponseSuccess",
)<{
  readonly frame: ResponseFrame;
  readonly id: JsonRpcId;
  readonly result: unknown;
}> {}

export type DecodedServerInbound =
  | DecodedResponseSuccess
  | DecodedResponseError
  | ({
      readonly _tag: "ServerRequest";
    } & DecodedRpcRequest<AnyTaskCallbackRpcDefinition>)

export function decodeServerInbound(
  parsed: unknown,
): Effect.Effect<DecodedServerInbound, MalformedFrameError>

export const DEFAULT_PAGE_LIMIT = 50

export class InvalidProtocolVersionError extends Data.TaggedError(
  "InvalidProtocolVersionError",
)<{ readonly version: string; readonly segment: string }> {
  override get message(): string {
    return `compareProtocolVersion: invalid segment ${JSON.stringify(this.segment)} in ${JSON.stringify(this.version)}`;
  }
}

export type JsonValue =
  | null
  | boolean
  | number
  | string
  | ReadonlyArray<JsonValue>

export const JsonValueSchema = Type.Recursive(
  (Self) =>
    Type.Union([
      Type.Null(),
      Type.Boolean(),
      Type.Number(),
      Type.String(),
      Type.Array(Self),
      Type.Record(Type.String(), Self),
    ]),
  { $id: "JsonValue" },
)

export type ListCursor = BrandedString<"ListCursor">;

export function listCursorSchema(): TString &

export const ListLimitSchema = Type.Optional(
  Type.Integer({ minimum: 1, maximum: MAX_PAGE_LIMIT }),
)

export const MAX_PAGE_LIMIT = 200

export const notificationDefinitions = [
  ...networkNotifications,
  ...identityNotifications,
  ...taskNotifications,
  ...appNotifications,
] as const

export const PROTOCOL_VERSION = "2026.529.0"

export type RegisteredTaggedError =
  | UnauthorizedError
  | ForbiddenError
  | NotFoundError
  | ConflictError
  | InvalidParamsError
  | NotInContactsError
  | TaskClosedError
  | TaskRejectedError
  | ConversationArchivedError
  | ConversationFullError
  | HookBlockedError
  // v11 (codex r10 P2 #2): protocol-version mismatch on
  // `network/connect`. Architect plan #706 v8 declared the class +
  // self-registered the wire code; v11 closes the type-narrowing
  // gap so `Effect.catchTag("ProtocolMismatchError", ...)` works.
  | ProtocolMismatchError;

// Spec D3 R11 — per-kind outbound catalogs.
//   `agentClientRpcMethods` — callable from `MoltZapAgentClient`.
//   `taskMasterRpcMethods`  — superset; adds TM-only operations.
//   `serverRpcMethods`      — server inbound; full union (still
//     includes the legacy `Conversations*` / plural `Tasks*` that
//     retire across Commits 6-10).
export const agentClientRpcMethods = [
  ...identityRpcMethods,
  ...networkRpcMethods,
  ...nonTmAuthorityTaskRpcMethods,
  ...appRpcMethods,
] as const;

export const serverRpcMethods = [
  ...identityRpcMethods,
  ...networkRpcMethods,
  ...taskRpcMethods,
  ...appRpcMethods,
] as const

export function stringEnum<T extends string[]>(values: [...T])

export const taskMasterRpcMethods = [
  ...agentClientRpcMethods,
  ...tmOnlyTaskRpcMethods,
] as const