@dual-os/sdk 0.0.0-stage → 0.8.0-next.0

package/dist/Group.d.ts

@@ -0,0 +1,106 @@
+import { Any as Any$1 } from "./Action.js";
+import { Any as Any$2 } from "./Trigger.js";
+import { FilterChildren } from "./internal/children.js";
+import { Pipeable } from "effect";
+declare namespace Group_d_exports {
+  export { ActionsFromChildren, AddChildren, Any, Group, GroupOptions, GroupsFromChildren, StructuralChild, TriggersFromChildren, TypeId, add, isGroup, make, withAction, withActions, withDescription, withGroup, withGroups, withName, withTrigger, withTriggers };
+}
+/** @since 0.0.0 @category type ids */
+export declare const TypeId: "@dual-os/sdk/Group";
+/** @since 0.0.0 @category type ids */
+export type TypeId = typeof TypeId;
+/** @since 0.0.0 @category type-level */
+export interface Any extends Pipeable.Pipeable {
+  readonly [TypeId]: TypeId;
+  readonly identifier: string;
+  readonly name: string | undefined;
+  readonly description: string | undefined;
+  readonly groups: readonly Any[];
+  readonly actions: readonly Any$1[];
+  readonly triggers: readonly Any$2[];
+}
+/** @since 0.0.0 @category models */
+export interface GroupOptions<Identifier extends string = string> {
+  readonly identifier: Identifier;
+  readonly name?: string;
+  readonly description?: string;
+}
+/** @since 0.0.0 @category models */
+export interface Group<out Identifier extends string = string, out Groups extends readonly Any[] = readonly [], out Actions extends readonly Any$1[] = readonly [], out Triggers extends readonly Any$2[] = readonly []> extends Pipeable.Pipeable {
+  readonly [TypeId]: TypeId;
+  readonly identifier: Identifier;
+  readonly name: string | undefined;
+  readonly description: string | undefined;
+  readonly groups: Groups;
+  readonly actions: Actions;
+  readonly triggers: Triggers;
+}
+export type StructuralChild = Any | Any$1 | Any$2;
+export type GroupsFromChildren<Children extends readonly StructuralChild[]> = FilterChildren<Children, Any>;
+export type ActionsFromChildren<Children extends readonly StructuralChild[]> = FilterChildren<Children, Any$1>;
+export type TriggersFromChildren<Children extends readonly StructuralChild[]> = FilterChildren<Children, Any$2>;
+/**
+ * Result of appending children to a group; shared by every child combinator so
+ * their overloads stay declarative.
+ *
+ * @since 0.0.0
+ * @category type-level
+ */
+export type AddChildren<Self extends Any, AddedGroups extends readonly Any[] = readonly [], AddedActions extends readonly Any$1[] = readonly [], AddedTriggers extends readonly Any$2[] = readonly []> = Self extends Group<infer Identifier, infer Groups, infer Actions, infer Triggers> ? Group<Identifier, readonly [...Groups, ...AddedGroups], readonly [...Actions, ...AddedActions], readonly [...Triggers, ...AddedTriggers]> : never;
+/** @since 0.0.0 @category constructors */
+export declare const make: <const Identifier extends string>(identifier: Identifier) => Group<Identifier>;
+/** @since 0.0.0 @category guards */
+export declare const isGroup: (u: unknown) => u is Any;
+/** @since 0.0.0 @category combinators */
+export declare const withName: {
+  (name: string): <G extends Group<any, any, any, any>>(group: G) => G;
+  <G extends Group<any, any, any, any>>(group: G, name: string): G;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withDescription: {
+  (description: string): <G extends Group<any, any, any, any>>(group: G) => G;
+  <G extends Group<any, any, any, any>>(group: G, description: string): G;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withGroups: {
+  <const AddedGroups extends readonly Any[]>(groups: AddedGroups): <Self extends Any>(group: Self) => AddChildren<Self, AddedGroups>;
+  <Self extends Any, const AddedGroups extends readonly Any[]>(group: Self, groups: AddedGroups): AddChildren<Self, AddedGroups>;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withActions: {
+  <const AddedActions extends readonly Any$1[]>(actions: AddedActions): <Self extends Any>(group: Self) => AddChildren<Self, readonly [], AddedActions>;
+  <Self extends Any, const AddedActions extends readonly Any$1[]>(group: Self, actions: AddedActions): AddChildren<Self, readonly [], AddedActions>;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withTriggers: {
+  <const AddedTriggers extends readonly Any$2[]>(triggers: AddedTriggers): <Self extends Any>(group: Self) => AddChildren<Self, readonly [], readonly [], AddedTriggers>;
+  <Self extends Any, const AddedTriggers extends readonly Any$2[]>(group: Self, triggers: AddedTriggers): AddChildren<Self, readonly [], readonly [], AddedTriggers>;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withGroup: {
+  <const AddedGroup extends Any>(group: AddedGroup): <Self extends Any>(value: Self) => AddChildren<Self, readonly [AddedGroup]>;
+  <Self extends Any, const AddedGroup extends Any>(value: Self, group: AddedGroup): AddChildren<Self, readonly [AddedGroup]>;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withAction: {
+  <const AddedAction extends Any$1>(action: AddedAction): <Self extends Any>(value: Self) => AddChildren<Self, readonly [], readonly [AddedAction]>;
+  <Self extends Any, const AddedAction extends Any$1>(value: Self, action: AddedAction): AddChildren<Self, readonly [], readonly [AddedAction]>;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withTrigger: {
+  <const AddedTrigger extends Any$2>(trigger: AddedTrigger): <Self extends Any>(value: Self) => AddChildren<Self, readonly [], readonly [], readonly [AddedTrigger]>;
+  <Self extends Any, const AddedTrigger extends Any$2>(value: Self, trigger: AddedTrigger): AddChildren<Self, readonly [], readonly [], readonly [AddedTrigger]>;
+};
+/**
+ * Add mixed structural children to a group.
+ *
+ * @since 0.0.0
+ * @category combinators
+ */
+export declare const add: {
+  <const Children extends readonly StructuralChild[]>(...children: Children): <Self extends Any>(group: Self) => AddChildren<Self, GroupsFromChildren<Children>, ActionsFromChildren<Children>, TriggersFromChildren<Children>>;
+  <Self extends Any, const Children extends readonly StructuralChild[]>(group: Self, ...children: Children): AddChildren<Self, GroupsFromChildren<Children>, ActionsFromChildren<Children>, TriggersFromChildren<Children>>;
+};
+//#endregion
+export { Group_d_exports };
+//# sourceMappingURL=Group.d.ts.map

package/dist/Group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Group.d.ts","names":["Action.Any","Trigger.Any"],"sources":["../src/Group.ts"],"mappings":";;;;;;;;qBAwBa;;YAED,gBAAgB;;iBAGX,YAAY,SAAS;YAC1B,SAAS;WACV;WACA;WACA;WACA,iBAAiB;WACjB,kBAAkBA;WAClB,mBAAmBC;;;iBAIb,aAAa;WACnB,YAAY;WACZ;WACA;;;iBAIM,UACX,wCACA,wBAAwB,yBACxB,yBAAyBD,2BACzB,0BAA0BC,+BAEtB,SAAS;YACP,SAAS;WACV,YAAY;WACZ;WACA;WACA,QAAQ;WACR,SAAS;WACT,UAAU;;YAGT,kBAAkB,MAAMD,QAAaC;YAErC,mBAAmB,0BAA0B,qBAAqB,eAC5E,UACA;YAGU,oBAAoB,0BAA0B,qBAAqB,eAC7E,UACAD;YAGU,qBAAqB,0BAA0B,qBAAqB,eAC9E,UACAC;;;;;;;;YAUU,YACV,aAAa,KACb,6BAA6B,qBAC7B,8BAA8BD,uBAC9B,+BAA+BC,yBAE/B,aAAa,YAAY,kBAAkB,cAAc,eAAe,YACpE,MACE,yBACa,WAAW,2BACX,YAAY,4BACZ,aAAa;;qBAwDrB,aAAc,2BAAyB,YAAc,eAAa,MAAM;;qBAIxE,UAAO,eAAiB,KAAK;;qBAG7B;GACV,gBAAgB,UAAU,2BAA2B,OAAO,MAAM;GAClE,UAAU,2BAA2B,OAAO,GAAG,eAAe;;;qBAapD;GACV,uBAAuB,UAAU,2BAA2B,OAAO,MAAM;GACzE,UAAU,2BAA2B,OAAO,GAAG,sBAAsB;;;qBAa3D;SACJ,6BAA6B,OAClC,QAAQ,eACN,aAAa,KAAK,OAAO,SAAS,YAAY,MAAM;GACvD,aAAa,WAAW,6BAA6B,OACpD,OAAO,MACP,QAAQ,cACP,YAAY,MAAM;;;qBAIV;SACJ,8BAA8BD,SACnC,SAAS,gBACP,aAAa,KAAK,OAAO,SAAS,YAAY,mBAAmB;GACpE,aAAa,WAAW,8BAA8BA,SACrD,OAAO,MACP,SAAS,eACR,YAAY,mBAAmB;;;qBAMvB;SACJ,+BAA+BC,SACpC,UAAU,iBACR,aAAa,KAAK,OAAO,SAAS,YAAY,gCAAgC;GACjF,aAAa,WAAW,+BAA+BA,SACtD,OAAO,MACP,UAAU,gBACT,YAAY,gCAAgC;;;qBAMpC;SACJ,mBAAmB,KACxB,OAAO,cACL,aAAa,KAAK,OAAO,SAAS,YAAY,gBAAgB;GACjE,aAAa,WAAW,mBAAmB,KAC1C,OAAO,MACP,OAAO,aACN,YAAY,gBAAgB;;;qBAIpB;SACJ,oBAAoBD,OACzB,QAAQ,eACN,aAAa,KAAK,OAAO,SAAS,YAAY,6BAA6B;GAC9E,aAAa,WAAW,oBAAoBA,OAC3C,OAAO,MACP,QAAQ,cACP,YAAY,6BAA6B;;;qBAIjC;SACJ,qBAAqBC,OAC1B,SAAS,gBACP,aAAa,KACf,OAAO,SACJ,YAAY,0CAA0C;GAC1D,aAAa,WAAW,qBAAqBA,OAC5C,OAAO,MACP,SAAS,eACR,YAAY,0CAA0C;;;;;;;;qBAS9C;SACJ,0BAA0B,sBAC5B,UAAU,YACX,aAAa,KACf,OAAO,SACJ,YACH,MACA,mBAAmB,WACnB,oBAAoB,WACpB,qBAAqB;GAEtB,aAAa,WAAW,0BAA0B,mBACjD,OAAO,SACJ,UAAU,WACZ,YACD,MACA,mBAAmB,WACnB,oBAAoB,WACpB,qBAAqB"}

package/dist/Group.js

@@ -0,0 +1,86 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { validateIdentifier } from "./internal/identifier.js";
+import { PipeableProto } from "./internal/proto.js";
+import { appendElements } from "./internal/collection-utils.js";
+import { assertUniqueMixedChildIdentifiers, assertUniqueStructuralChildIdentifiers, partitionChildren } from "./internal/children.js";
+import { Function, Predicate } from "effect";
+//#region src/Group.ts
+var Group_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	add: () => add,
+	isGroup: () => isGroup,
+	make: () => make,
+	withAction: () => withAction,
+	withActions: () => withActions,
+	withDescription: () => withDescription,
+	withGroup: () => withGroup,
+	withGroups: () => withGroups,
+	withName: () => withName,
+	withTrigger: () => withTrigger,
+	withTriggers: () => withTriggers
+});
+/** @since 0.0.0 @category type ids */
+const TypeId = "@dual-os/sdk/Group";
+const optionsFromGroup = (group) => ({
+	identifier: group.identifier,
+	...group.name === void 0 ? {} : { name: group.name },
+	...group.description === void 0 ? {} : { description: group.description }
+});
+const Proto = {
+	...PipeableProto,
+	[TypeId]: TypeId
+};
+const makeGroup = (options, groups, actions, triggers) => {
+	validateIdentifier("group", options.identifier);
+	return Object.assign(Object.create(Proto), {
+		actions,
+		description: options.description,
+		groups,
+		identifier: options.identifier,
+		name: options.name,
+		triggers
+	});
+};
+const appendChildren = (group, children, childKind) => {
+	if (childKind === void 0) assertUniqueMixedChildIdentifiers("group", group.identifier, group, children);
+	else assertUniqueStructuralChildIdentifiers("group", group.identifier, group, children, childKind);
+	const partitioned = partitionChildren(children);
+	return makeGroup(optionsFromGroup(group), appendElements(group.groups, partitioned.groups), appendElements(group.actions, partitioned.actions), appendElements(group.triggers, partitioned.triggers));
+};
+/** @since 0.0.0 @category constructors */
+const make = (identifier) => makeGroup({ identifier }, [], [], []);
+/** @since 0.0.0 @category guards */
+const isGroup = (u) => Predicate.hasProperty(u, TypeId);
+/** @since 0.0.0 @category combinators */
+const withName = Function.dual(2, (group, name) => makeGroup({
+	...optionsFromGroup(group),
+	name
+}, group.groups, group.actions, group.triggers));
+/** @since 0.0.0 @category combinators */
+const withDescription = Function.dual(2, (group, description) => makeGroup({
+	...optionsFromGroup(group),
+	description
+}, group.groups, group.actions, group.triggers));
+/** @since 0.0.0 @category combinators */
+const withGroups = Function.dual(2, (group, groups) => appendChildren(group, groups, "group"));
+/** @since 0.0.0 @category combinators */
+const withActions = Function.dual(2, (group, actions) => appendChildren(group, actions, "action"));
+/** @since 0.0.0 @category combinators */
+const withTriggers = Function.dual(2, (group, triggers) => appendChildren(group, triggers, "trigger"));
+/** @since 0.0.0 @category combinators */
+const withGroup = Function.dual(2, (value, group) => appendChildren(value, [group], "group"));
+/** @since 0.0.0 @category combinators */
+const withAction = Function.dual(2, (value, action) => appendChildren(value, [action], "action"));
+/** @since 0.0.0 @category combinators */
+const withTrigger = Function.dual(2, (value, trigger) => appendChildren(value, [trigger], "trigger"));
+/**
+* Add mixed structural children to a group.
+*
+* @since 0.0.0
+* @category combinators
+*/
+const add = Function.dual((args) => isGroup(args[0]), (group, ...children) => appendChildren(group, children));
+//#endregion
+export { Group_exports, TypeId, add, isGroup, make, withAction, withActions, withDescription, withGroup, withGroups, withName, withTrigger, withTriggers };
+
+//# sourceMappingURL=Group.js.map

package/dist/Group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Group.js","names":["Func"],"sources":["../src/Group.ts"],"sourcesContent":["/**\n * Canonical group definition builders and types for the Dual SDK.\n *\n * Groups are structural namespaces nested beneath providers or other groups.\n *\n * @since 0.0.0\n */\nimport type { Pipeable } from \"effect\";\nimport { Function as Func, Predicate } from \"effect\";\n\nimport type * as Action from \"./Action.ts\";\nimport {\n  assertUniqueMixedChildIdentifiers,\n  assertUniqueStructuralChildIdentifiers,\n  type FilterChildren,\n  partitionChildren,\n  type StructuralChildKind,\n} from \"./internal/children.ts\";\nimport { appendElements } from \"./internal/collection-utils.ts\";\nimport { validateIdentifier } from \"./internal/identifier.ts\";\nimport { PipeableProto } from \"./internal/proto.ts\";\nimport type * as Trigger from \"./Trigger.ts\";\n\n/** @since 0.0.0 @category type ids */\nexport const TypeId = \"@dual-os/sdk/Group\" as const;\n/** @since 0.0.0 @category type ids */\nexport type TypeId = typeof TypeId;\n\n/** @since 0.0.0 @category type-level */\nexport interface Any extends Pipeable.Pipeable {\n  readonly [TypeId]: TypeId;\n  readonly identifier: string;\n  readonly name: string | undefined;\n  readonly description: string | undefined;\n  readonly groups: readonly Any[];\n  readonly actions: readonly Action.Any[];\n  readonly triggers: readonly Trigger.Any[];\n}\n\n/** @since 0.0.0 @category models */\nexport interface GroupOptions<Identifier extends string = string> {\n  readonly identifier: Identifier;\n  readonly name?: string;\n  readonly description?: string;\n}\n\n/** @since 0.0.0 @category models */\nexport interface Group<\n  out Identifier extends string = string,\n  out Groups extends readonly Any[] = readonly [],\n  out Actions extends readonly Action.Any[] = readonly [],\n  out Triggers extends readonly Trigger.Any[] = readonly [],\n>\n  extends Pipeable.Pipeable {\n  readonly [TypeId]: TypeId;\n  readonly identifier: Identifier;\n  readonly name: string | undefined;\n  readonly description: string | undefined;\n  readonly groups: Groups;\n  readonly actions: Actions;\n  readonly triggers: Triggers;\n}\n\nexport type StructuralChild = Any | Action.Any | Trigger.Any;\n\nexport type GroupsFromChildren<Children extends readonly StructuralChild[]> = FilterChildren<\n  Children,\n  Any\n>;\n\nexport type ActionsFromChildren<Children extends readonly StructuralChild[]> = FilterChildren<\n  Children,\n  Action.Any\n>;\n\nexport type TriggersFromChildren<Children extends readonly StructuralChild[]> = FilterChildren<\n  Children,\n  Trigger.Any\n>;\n\n/**\n * Result of appending children to a group; shared by every child combinator so\n * their overloads stay declarative.\n *\n * @since 0.0.0\n * @category type-level\n */\nexport type AddChildren<\n  Self extends Any,\n  AddedGroups extends readonly Any[] = readonly [],\n  AddedActions extends readonly Action.Any[] = readonly [],\n  AddedTriggers extends readonly Trigger.Any[] = readonly [],\n> =\n  Self extends Group<infer Identifier, infer Groups, infer Actions, infer Triggers>\n    ? Group<\n        Identifier,\n        readonly [...Groups, ...AddedGroups],\n        readonly [...Actions, ...AddedActions],\n        readonly [...Triggers, ...AddedTriggers]\n      >\n    : never;\n\nconst optionsFromGroup = (group: Any): GroupOptions => ({\n  identifier: group.identifier,\n  ...(group.name === undefined ? {} : { name: group.name }),\n  ...(group.description === undefined ? {} : { description: group.description }),\n});\n\nconst Proto = { ...PipeableProto, [TypeId]: TypeId };\n\nconst makeGroup = <\n  Identifier extends string,\n  Groups extends readonly Any[],\n  Actions extends readonly Action.Any[],\n  Triggers extends readonly Trigger.Any[],\n>(\n  options: GroupOptions<Identifier>,\n  groups: Groups,\n  actions: Actions,\n  triggers: Triggers,\n): Group<Identifier, Groups, Actions, Triggers> => {\n  validateIdentifier(\"group\", options.identifier);\n\n  return Object.assign(Object.create(Proto), {\n    actions,\n    description: options.description,\n    groups,\n    identifier: options.identifier,\n    name: options.name,\n    triggers,\n  }) as Group<Identifier, Groups, Actions, Triggers>;\n};\n\nconst appendChildren = (\n  group: Any,\n  children: readonly StructuralChild[],\n  childKind?: StructuralChildKind,\n): Any => {\n  if (childKind === undefined) {\n    assertUniqueMixedChildIdentifiers(\"group\", group.identifier, group, children);\n  } else {\n    assertUniqueStructuralChildIdentifiers(\"group\", group.identifier, group, children, childKind);\n  }\n\n  const partitioned = partitionChildren(children);\n  return makeGroup(\n    optionsFromGroup(group),\n    appendElements(group.groups, partitioned.groups),\n    appendElements(group.actions, partitioned.actions),\n    appendElements(group.triggers, partitioned.triggers),\n  );\n};\n\n/** @since 0.0.0 @category constructors */\nexport const make = <const Identifier extends string>(identifier: Identifier): Group<Identifier> =>\n  makeGroup({ identifier }, [] as const, [] as const, [] as const);\n\n/** @since 0.0.0 @category guards */\nexport const isGroup = (u: unknown): u is Any => Predicate.hasProperty(u, TypeId);\n\n/** @since 0.0.0 @category combinators */\nexport const withName: {\n  (name: string): <G extends Group<any, any, any, any>>(group: G) => G;\n  <G extends Group<any, any, any, any>>(group: G, name: string): G;\n} = Func.dual(\n  2,\n  <G extends Group<any, any, any, any>>(group: G, name: string): G =>\n    makeGroup(\n      { ...optionsFromGroup(group), name },\n      group.groups,\n      group.actions,\n      group.triggers,\n    ) as G,\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withDescription: {\n  (description: string): <G extends Group<any, any, any, any>>(group: G) => G;\n  <G extends Group<any, any, any, any>>(group: G, description: string): G;\n} = Func.dual(\n  2,\n  <G extends Group<any, any, any, any>>(group: G, description: string): G =>\n    makeGroup(\n      { ...optionsFromGroup(group), description },\n      group.groups,\n      group.actions,\n      group.triggers,\n    ) as G,\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withGroups: {\n  <const AddedGroups extends readonly Any[]>(\n    groups: AddedGroups,\n  ): <Self extends Any>(group: Self) => AddChildren<Self, AddedGroups>;\n  <Self extends Any, const AddedGroups extends readonly Any[]>(\n    group: Self,\n    groups: AddedGroups,\n  ): AddChildren<Self, AddedGroups>;\n} = Func.dual(2, (group: Any, groups: readonly Any[]) => appendChildren(group, groups, \"group\"));\n\n/** @since 0.0.0 @category combinators */\nexport const withActions: {\n  <const AddedActions extends readonly Action.Any[]>(\n    actions: AddedActions,\n  ): <Self extends Any>(group: Self) => AddChildren<Self, readonly [], AddedActions>;\n  <Self extends Any, const AddedActions extends readonly Action.Any[]>(\n    group: Self,\n    actions: AddedActions,\n  ): AddChildren<Self, readonly [], AddedActions>;\n} = Func.dual(2, (group: Any, actions: readonly Action.Any[]) =>\n  appendChildren(group, actions, \"action\"),\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withTriggers: {\n  <const AddedTriggers extends readonly Trigger.Any[]>(\n    triggers: AddedTriggers,\n  ): <Self extends Any>(group: Self) => AddChildren<Self, readonly [], readonly [], AddedTriggers>;\n  <Self extends Any, const AddedTriggers extends readonly Trigger.Any[]>(\n    group: Self,\n    triggers: AddedTriggers,\n  ): AddChildren<Self, readonly [], readonly [], AddedTriggers>;\n} = Func.dual(2, (group: Any, triggers: readonly Trigger.Any[]) =>\n  appendChildren(group, triggers, \"trigger\"),\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withGroup: {\n  <const AddedGroup extends Any>(\n    group: AddedGroup,\n  ): <Self extends Any>(value: Self) => AddChildren<Self, readonly [AddedGroup]>;\n  <Self extends Any, const AddedGroup extends Any>(\n    value: Self,\n    group: AddedGroup,\n  ): AddChildren<Self, readonly [AddedGroup]>;\n} = Func.dual(2, (value: Any, group: Any) => appendChildren(value, [group], \"group\"));\n\n/** @since 0.0.0 @category combinators */\nexport const withAction: {\n  <const AddedAction extends Action.Any>(\n    action: AddedAction,\n  ): <Self extends Any>(value: Self) => AddChildren<Self, readonly [], readonly [AddedAction]>;\n  <Self extends Any, const AddedAction extends Action.Any>(\n    value: Self,\n    action: AddedAction,\n  ): AddChildren<Self, readonly [], readonly [AddedAction]>;\n} = Func.dual(2, (value: Any, action: Action.Any) => appendChildren(value, [action], \"action\"));\n\n/** @since 0.0.0 @category combinators */\nexport const withTrigger: {\n  <const AddedTrigger extends Trigger.Any>(\n    trigger: AddedTrigger,\n  ): <Self extends Any>(\n    value: Self,\n  ) => AddChildren<Self, readonly [], readonly [], readonly [AddedTrigger]>;\n  <Self extends Any, const AddedTrigger extends Trigger.Any>(\n    value: Self,\n    trigger: AddedTrigger,\n  ): AddChildren<Self, readonly [], readonly [], readonly [AddedTrigger]>;\n} = Func.dual(2, (value: Any, trigger: Trigger.Any) => appendChildren(value, [trigger], \"trigger\"));\n\n/**\n * Add mixed structural children to a group.\n *\n * @since 0.0.0\n * @category combinators\n */\nexport const add: {\n  <const Children extends readonly StructuralChild[]>(\n    ...children: Children\n  ): <Self extends Any>(\n    group: Self,\n  ) => AddChildren<\n    Self,\n    GroupsFromChildren<Children>,\n    ActionsFromChildren<Children>,\n    TriggersFromChildren<Children>\n  >;\n  <Self extends Any, const Children extends readonly StructuralChild[]>(\n    group: Self,\n    ...children: Children\n  ): AddChildren<\n    Self,\n    GroupsFromChildren<Children>,\n    ActionsFromChildren<Children>,\n    TriggersFromChildren<Children>\n  >;\n} = Func.dual(\n  args => isGroup(args[0]),\n  (group: Any, ...children: readonly StructuralChild[]) => appendChildren(group, children),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,SAAS;AA8EtB,MAAM,oBAAoB,WAA8B;CACtD,YAAY,MAAM;CAClB,GAAI,MAAM,SAAS,KAAA,IAAY,CAAC,IAAI,EAAE,MAAM,MAAM,KAAK;CACvD,GAAI,MAAM,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,aAAa,MAAM,YAAY;AAC9E;AAEA,MAAM,QAAQ;CAAE,GAAG;EAAgB,SAAS;AAAO;AAEnD,MAAM,aAMJ,SACA,QACA,SACA,aACiD;CACjD,mBAAmB,SAAS,QAAQ,UAAU;CAE9C,OAAO,OAAO,OAAO,OAAO,OAAO,KAAK,GAAG;EACzC;EACA,aAAa,QAAQ;EACrB;EACA,YAAY,QAAQ;EACpB,MAAM,QAAQ;EACd;CACF,CAAC;AACH;AAEA,MAAM,kBACJ,OACA,UACA,cACQ;CACR,IAAI,cAAc,KAAA,GAChB,kCAAkC,SAAS,MAAM,YAAY,OAAO,QAAQ;MAE5E,uCAAuC,SAAS,MAAM,YAAY,OAAO,UAAU,SAAS;CAG9F,MAAM,cAAc,kBAAkB,QAAQ;CAC9C,OAAO,UACL,iBAAiB,KAAK,GACtB,eAAe,MAAM,QAAQ,YAAY,MAAM,GAC/C,eAAe,MAAM,SAAS,YAAY,OAAO,GACjD,eAAe,MAAM,UAAU,YAAY,QAAQ,CACrD;AACF;;AAGA,MAAa,QAAyC,eACpD,UAAU,EAAE,WAAW,GAAG,CAAC,GAAY,CAAC,GAAY,CAAC,CAAU;;AAGjE,MAAa,WAAW,MAAyB,UAAU,YAAY,GAAG,MAAM;;AAGhF,MAAa,WAGTA,SAAK,KACP,IACsC,OAAU,SAC9C,UACE;CAAE,GAAG,iBAAiB,KAAK;CAAG;AAAK,GACnC,MAAM,QACN,MAAM,SACN,MAAM,QACR,CACJ;;AAGA,MAAa,kBAGTA,SAAK,KACP,IACsC,OAAU,gBAC9C,UACE;CAAE,GAAG,iBAAiB,KAAK;CAAG;AAAY,GAC1C,MAAM,QACN,MAAM,SACN,MAAM,QACR,CACJ;;AAGA,MAAa,aAQTA,SAAK,KAAK,IAAI,OAAY,WAA2B,eAAe,OAAO,QAAQ,OAAO,CAAC;;AAG/F,MAAa,cAQTA,SAAK,KAAK,IAAI,OAAY,YAC5B,eAAe,OAAO,SAAS,QAAQ,CACzC;;AAGA,MAAa,eAQTA,SAAK,KAAK,IAAI,OAAY,aAC5B,eAAe,OAAO,UAAU,SAAS,CAC3C;;AAGA,MAAa,YAQTA,SAAK,KAAK,IAAI,OAAY,UAAe,eAAe,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC;;AAGpF,MAAa,aAQTA,SAAK,KAAK,IAAI,OAAY,WAAuB,eAAe,OAAO,CAAC,MAAM,GAAG,QAAQ,CAAC;;AAG9F,MAAa,cAUTA,SAAK,KAAK,IAAI,OAAY,YAAyB,eAAe,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC;;;;;;;AAQlG,MAAa,MAoBTA,SAAK,MACP,SAAQ,QAAQ,KAAK,EAAE,IACtB,OAAY,GAAG,aAAyC,eAAe,OAAO,QAAQ,CACzF"}

package/dist/Http.d.ts

@@ -0,0 +1,342 @@
+import { Any } from "./AuthMethod.js";
+import { ActionHandlerError, ActionHandlerFailure, HandlerContext, RetryableActionHandlerError } from "./Action.js";
+import { File as File$1 } from "./Files.js";
+import "./Http.js";
+import { Effect, Record, Schema } from "effect";
+import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";
+declare namespace Http_d_exports {
+  export { Base64FromFile, Base64UrlFromFile, Contract, DataUriFromFile, DateTimeFromRfc2822, DateTimeFromUnixSeconds, Decoded, DecodedEndpoint, Endpoint, File, FileFromBase64, FileFromBase64Url, FileFromDataUri, Handler, Http_d_exports as Http, Rfc2822FromDateTime, UnixSecondsFromDateTime, Variant, continuation, decoded, form, literal, make, params, path, preauthenticated, segments, withFile, withForm };
+}
+/**
+ * An action's input and output schemas.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface Contract {
+  readonly input: Schema.Top;
+  readonly output: Schema.Top;
+}
+/**
+ * Runs an action: its input in, its output or a failure out.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export type Handler<Methods extends readonly Any[], Input, Output> = (input: Input, context: HandlerContext<Methods>) => Effect.Effect<Output, ActionHandlerFailure, HttpClient.HttpClient>;
+/**
+ * A file input: a ToolFile as a download returns it, or just its bytes with a type and name.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export type File = typeof File.Type;
+export declare const File: Schema.Struct<{
+  readonly _tag: Schema.optionalKey<Schema.Literal<"ToolFile">>;
+  readonly contentBase64: Schema.Uint8ArrayFromBase64;
+  readonly contentType: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+  readonly filename: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+  readonly sizeBytes: Schema.optionalKey<Schema.Natural>;
+}>;
+/**
+ * A file the API returns as a Base64 string inside JSON, decoded into a ToolFile with its content
+ * type recognized from the bytes.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const FileFromBase64: Schema.decodeTo<Schema.TaggedStruct<"ToolFile", {
+  readonly contentBase64: Schema.String;
+  readonly contentType: Schema.NullOr<Schema.String>;
+  readonly filename: Schema.NullOr<Schema.String>;
+  readonly sizeBytes: Schema.Natural;
+}>, Schema.String, never, never>;
+/**
+ * {@link FileFromBase64} for an API that writes the file in Base64Url.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const FileFromBase64Url: Schema.decodeTo<Schema.TaggedStruct<"ToolFile", {
+  readonly contentBase64: Schema.String;
+  readonly contentType: Schema.NullOr<Schema.String>;
+  readonly filename: Schema.NullOr<Schema.String>;
+  readonly sizeBytes: Schema.Natural;
+}>, Schema.String, never, never>;
+/**
+ * A {@link File} input the API reads as a Base64 string inside JSON.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const Base64FromFile: Schema.decodeTo<Schema.String, Schema.Struct<{
+  readonly _tag: Schema.optionalKey<Schema.Literal<"ToolFile">>;
+  readonly contentBase64: Schema.Uint8ArrayFromBase64;
+  readonly contentType: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+  readonly filename: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+  readonly sizeBytes: Schema.optionalKey<Schema.Natural>;
+}>, never, never>;
+/**
+ * {@link Base64FromFile} for an API that reads the file in Base64Url.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const Base64UrlFromFile: Schema.decodeTo<Schema.String, Schema.Struct<{
+  readonly _tag: Schema.optionalKey<Schema.Literal<"ToolFile">>;
+  readonly contentBase64: Schema.Uint8ArrayFromBase64;
+  readonly contentType: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+  readonly filename: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+  readonly sizeBytes: Schema.optionalKey<Schema.Natural>;
+}>, never, never>;
+/**
+ * {@link FileFromBase64} for an API that writes the file as a data URI, which also carries its
+ * content type.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const FileFromDataUri: Schema.decodeTo<Schema.TaggedStruct<"ToolFile", {
+  readonly contentBase64: Schema.String;
+  readonly contentType: Schema.NullOr<Schema.String>;
+  readonly filename: Schema.NullOr<Schema.String>;
+  readonly sizeBytes: Schema.Natural;
+}>, Schema.String, never, never>;
+/**
+ * {@link Base64FromFile} for an API that reads the file as a data URI, built from the file's
+ * content type.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const DataUriFromFile: Schema.decodeTo<Schema.String, Schema.Struct<{
+  readonly _tag: Schema.optionalKey<Schema.Literal<"ToolFile">>;
+  readonly contentBase64: Schema.Uint8ArrayFromBase64;
+  readonly contentType: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+  readonly filename: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+  readonly sizeBytes: Schema.optionalKey<Schema.Natural>;
+}>, never, never>;
+/**
+ * A date-time the API writes as Unix seconds, decoded into an ISO 8601 UTC string.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const DateTimeFromUnixSeconds: Schema.decodeTo<Schema.String, Schema.Codec<number, number, never, never>, never, never>;
+/**
+ * An ISO 8601 date-time input the API reads as Unix seconds.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const UnixSecondsFromDateTime: Schema.decodeTo<Schema.Codec<number, number, never, never>, Schema.String, never, never>;
+/**
+ * A date-time the API writes in RFC 2822 form, decoded into an ISO 8601 UTC string.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const DateTimeFromRfc2822: Schema.decodeTo<Schema.String, Schema.Codec<string, string, never, never>, never, never>;
+/**
+ * An ISO 8601 date-time input the API reads in RFC 2822 form.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const Rfc2822FromDateTime: Schema.decodeTo<Schema.Codec<string, string, never, never>, Schema.String, never, never>;
+/**
+ * An action output whose response decodes into a different shape, such as a file the API sends as
+ * Base64: the action declares the decoded shape and the call decodes the response with `wire`.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface Decoded<Wire extends Schema.Top> {
+  readonly _tag: "Decoded";
+  readonly wire: Wire;
+}
+/**
+ * Declares an output by the response schema it decodes from; see {@link Decoded}.
+ *
+ * @since 0.0.0
+ * @category constructors
+ */
+export declare function decoded<const Wire extends Schema.Top>(wire: Wire): Decoded<Wire>;
+type Request = HttpClientRequest.HttpClientRequest | Effect.Effect<HttpClientRequest.HttpClientRequest, ActionHandlerError>;
+/** `binary` returns a released version's base64 `ToolFile`; `file` stores the body as a file. */
+type Body = "json" | "text" | "binary" | "file" | "void" | "unknown";
+/**
+ * A response status, media type and decoding mode advertised by an HTTP action.
+ *
+ * @since 0.4.1
+ * @category models
+ */
+export interface Variant {
+  readonly status?: number;
+  readonly contentType: string;
+  readonly body: Body;
+  readonly headers?: readonly string[];
+}
+type Media = {
+  readonly contentBase64: Uint8Array;
+  readonly contentType?: string | null;
+} | File$1;
+type Upload = {
+  readonly mode: "media";
+  readonly media: Media;
+} | {
+  readonly mode: "multipart";
+  readonly media: Media;
+  readonly metadata: unknown;
+} | {
+  readonly mode: "start";
+  readonly contentType: string;
+  readonly metadata?: unknown;
+  readonly totalBytes: number;
+} | {
+  readonly mode: "chunk";
+  readonly sessionUrl: string;
+  readonly totalBytes: number;
+  readonly offset: number;
+  readonly media: Media;
+} | {
+  readonly mode: "status";
+  readonly sessionUrl: string;
+  readonly totalBytes: number;
+};
+/**
+ * Encodes a path parameter as one segment.
+ *
+ * @since 0.0.0
+ * @category encoding
+ */
+export declare function path(value: unknown): string;
+/**
+ * Encodes a path parameter written inside single quotes, an OData string literal, doubling its
+ * quotes: `O'Brien` in `People('{name}')` is sent as `People('O''Brien')`.
+ *
+ * @since 0.0.0
+ * @category encoding
+ */
+export declare function literal(value: unknown): string;
+/**
+ * Encodes a path parameter whose slashes stay path separators.
+ *
+ * @since 0.0.0
+ * @category encoding
+ */
+export declare function segments(value: unknown): string;
+/**
+ * Query, header or form entries, repeating array values unless their name is joined, and encoding
+ * `deep` names as bracketed keys such as `metadata[plan]` and `expand[0]`. A joined name is
+ * comma-separated, or separated by the delimiter it is paired with, such as `["ids", "|"]`.
+ * `exploded` object parameters use their property names as query keys (`role=vet&active=true`).
+ *
+ * @since 0.0.0
+ * @category encoding
+ */
+export declare function params(fields: Record.ReadonlyRecord<string, unknown>, joined?: readonly (string | readonly [string, string])[], deep?: readonly string[], exploded?: readonly string[]): (readonly [string, string])[];
+/**
+ * Multipart form fields, sending each {@link File} as a file part.
+ *
+ * @since 0.0.0
+ * @category encoding
+ */
+export declare function form(payload: Record.ReadonlyRecord<string, unknown>): Record<string, (string | globalThis.File | undefined)[]>;
+/**
+ * Sends a file as the raw request body.
+ *
+ * @since 0.1.0
+ * @category encoding
+ */
+export declare const withFile: (request: HttpClientRequest.HttpClientRequest, file: {
+  readonly _tag: "File";
+  readonly contentType: string;
+  readonly id: string;
+  readonly name: string;
+  readonly sizeBytes: number;
+}) => Effect.Effect<HttpClientRequest.HttpClientRequest, ActionHandlerError, never>;
+/**
+ * Sends multipart form fields, each {@link Files.File} as a file part.
+ *
+ * @since 0.1.0
+ * @category encoding
+ */
+export declare const withForm: (request: HttpClientRequest.HttpClientRequest, payload: Record.ReadonlyRecord<string, unknown>) => Effect.Effect<HttpClientRequest.HttpClientRequest, ActionHandlerError, never>;
+/**
+ * Follows a returned next-page link on the operation's own origin: only its path and query are
+ * taken, so the connection's host routing applies and credentials never reach another host.
+ *
+ * @since 0.0.0
+ * @category requests
+ */
+export declare function continuation(request: HttpClientRequest.HttpClientRequest, nextLink?: string): Effect.Effect<never, ActionHandlerError, never> | Effect.Effect<HttpClientRequest.HttpClientRequest, never, never>;
+/**
+ * A request to a preauthenticated upload URL, which is sent without the connection's credentials.
+ *
+ * @since 0.0.0
+ * @category requests
+ */
+export declare function preauthenticated(method: (url: string) => HttpClientRequest.HttpClientRequest, url: string, ...steps: readonly ((request: HttpClientRequest.HttpClientRequest) => HttpClientRequest.HttpClientRequest)[]): Effect.Effect<never, ActionHandlerError, never> | Effect.Effect<HttpClientRequest.HttpClientRequest, never, never>;
+/**
+ * One API operation as {@link make} returns it: its contract and the call that performs it. The
+ * `Context` parameter lets a package name its handler context once, so declaration files print
+ * `Endpoint<Context, …>` instead of repeating its auth methods in every action.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface Endpoint<Context, Input extends Schema.Top, Output extends Schema.Top> {
+  readonly input: Input;
+  readonly output: Output;
+  readonly run: (input: Input["Type"], context: Context) => Effect.Effect<Output["Type"], ActionHandlerFailure, HttpClient.HttpClient>;
+}
+/**
+ * An {@link Endpoint} whose output is the decoded type of the response schema it keeps as `wire`.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface DecodedEndpoint<Context, Input extends Schema.Top, Wire extends Schema.Top> {
+  readonly input: Input;
+  readonly output: Schema.toType<Wire>;
+  readonly wire: Wire;
+  readonly run: (input: Input["Type"], context: Context) => Effect.Effect<Wire["Type"], ActionHandlerFailure, HttpClient.HttpClient>;
+}
+/**
+ * Binds the runtime to a package's auth module: the calls a generated version file makes. Its
+ * `authorize` applies a connection's credentials to the client. Its optional `checkResponse` fails
+ * a successful response that reports a failed call, such as Slack's `{ ok: false, error }`.
+ * `preauthenticatedUploadUrl` restricts credential-free upload requests and every redirect to
+ * provider-approved HTTPS URLs, without changing authenticated calls or other providers.
+ *
+ * @since 0.0.0
+ * @category constructors
+ */
+export declare function make<const Methods extends readonly Any[], Context extends HandlerContext<Methods> = HandlerContext<Methods>>(auth: {
+  readonly authorize: (client: HttpClient.HttpClient, context: HandlerContext<Methods>) => HttpClient.HttpClient;
+  readonly checkResponse?: (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<void, ActionHandlerError | HttpClientError.HttpClientError>;
+  readonly preauthenticatedUploadUrl?: Schema.Schema<string>;
+}): {
+  endpoint: {
+    <const Input extends Schema.Top, const Output extends Schema.Top>(contract: {
+      readonly input: Input;
+      readonly output: Output;
+    }, run: (input: Input["Type"], context: Context, output: Output) => Effect.Effect<Output["Type"], ActionHandlerFailure, HttpClient.HttpClient>): Endpoint<Context, Input, Output>;
+    <const Input extends Schema.Top, const Wire extends Schema.Top>(contract: {
+      readonly input: Input;
+      readonly output: Decoded<Wire>;
+    }, run: (input: Input["Type"], context: Context, output: Wire) => Effect.Effect<Wire["Type"], ActionHandlerFailure, HttpClient.HttpClient>): DecodedEndpoint<Context, Input, Wire>;
+  };
+  execute: <Output extends Schema.Top>(context: Context | undefined, output: Output, request: Request, body: Body) => Effect.Effect<Output["Type"], ActionHandlerError | RetryableActionHandlerError, HttpClient.HttpClient | Output["DecodingServices"]>;
+  googleUpload: <Output extends Schema.Top>(context: Context, output: Output, request: HttpClientRequest.HttpClientRequest, payload: Upload, options: {
+    readonly maxSize?: number;
+    readonly resumable?: string;
+  }) => Effect.Effect<Output["Type"], ActionHandlerError | RetryableActionHandlerError, HttpClient.HttpClient | Output["DecodingServices"]>;
+  graphql: <Output extends Schema.Top>(context: Context, output: Output, request: Request, field: string) => Effect.Effect<Output["Type"], ActionHandlerError | RetryableActionHandlerError, HttpClient.HttpClient | Output["DecodingServices"]>;
+  mcp: <Output extends Schema.Top>(context: Context, output: Output, server: string, tool: string, args: unknown, structured: boolean) => Effect.Effect<Output["Type"], ActionHandlerError | RetryableActionHandlerError, HttpClient.HttpClient | Exclude<Output["DecodingServices"], import("effect/Scope").Scope>>;
+  variants: <Output extends Schema.Top>(context: Context | undefined, output: Output, request: Request, declared: readonly Variant[], media?: boolean | undefined) => Effect.Effect<Output["Type"], ActionHandlerError | RetryableActionHandlerError, HttpClient.HttpClient | Output["DecodingServices"]>;
+};
+//#endregion
+export { Http_d_exports as Http, Http_d_exports };
+//# sourceMappingURL=Http.d.ts.map

package/dist/Http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Http.d.ts","names":["AuthMethod.Any","Action.HandlerContext","Action.ActionHandlerFailure","Action.ActionHandlerError","Files.File","Action.RetryableActionHandlerError"],"sources":["../src/Http.ts"],"mappings":"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"}