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

package/dist/AiProvider.d.ts

@@ -0,0 +1,132 @@
+import { BindingFor } from "./AuthMethodBinding.js";
+import { Any as Any$1 } from "./AuthMethod.js";
+import { Category } from "./Plugin.js";
+import { Pipeable, Schema } from "effect";
+declare namespace AiProvider_d_exports {
+  export { AddAuthMethods, AiProvider, AiProviderOptions, Any, RuntimeConfig, RuntimeConfigResolver, RuntimeConfigResolverInput, RuntimeModel, TypeId, isAiProvider, make, registryId, withAuthMethod, withAuthMethods, withCategories, withDescription, withDocsUrl, withHomepageUrl, withIconUrl, withIconUrlDark, withName, withRuntimeConfig };
+}
+/** @since 0.0.0 @category type ids */
+export declare const TypeId: "@dual-os/sdk/AiProvider";
+/** @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 iconUrl: string | undefined;
+  readonly iconUrlDark: string | undefined;
+  readonly categories: readonly Category[];
+  readonly homepageUrl: string | undefined;
+  readonly docsUrl: string | undefined;
+  readonly authMethods: readonly Any$1[];
+  readonly resolveRuntimeConfig: unknown;
+}
+/** @since 0.0.0 @category models */
+export declare const RuntimeConfig: Schema.Struct<{
+  readonly apiKey: Schema.optional<Schema.String>;
+  readonly baseUrl: Schema.optional<Schema.String>;
+  readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+  readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.NullOr<Schema.String>>>;
+}>;
+/** @since 0.0.0 @category models */
+export type RuntimeConfig = typeof RuntimeConfig.Type;
+/** @since 0.0.0 @category models */
+export interface RuntimeModel {
+  readonly id: string;
+  readonly baseUrl: string;
+}
+/** @since 0.0.0 @category models */
+export interface RuntimeConfigResolverInput<Methods extends readonly Any$1[]> {
+  readonly model: RuntimeModel;
+  readonly binding: BindingFor<Methods>;
+}
+/** @since 0.0.0 @category models */
+export type RuntimeConfigResolver<Methods extends readonly Any$1[]> = (input: RuntimeConfigResolverInput<Methods>) => RuntimeConfig;
+/** @since 0.0.0 @category models */
+export interface AiProviderOptions<Identifier extends string = string> {
+  readonly identifier: Identifier;
+  readonly name?: string;
+  readonly description?: string;
+  readonly iconUrl?: string;
+  readonly iconUrlDark?: string;
+  readonly categories?: readonly Category[];
+  readonly homepageUrl?: string;
+  readonly docsUrl?: string;
+}
+/** @since 0.0.0 @category models */
+export interface AiProvider<out Identifier extends string = string, out AuthMethods extends readonly Any$1[] = readonly []> extends Pipeable.Pipeable {
+  readonly [TypeId]: TypeId;
+  readonly identifier: Identifier;
+  readonly name: string | undefined;
+  readonly description: string | undefined;
+  readonly iconUrl: string | undefined;
+  readonly iconUrlDark: string | undefined;
+  readonly categories: readonly Category[];
+  readonly homepageUrl: string | undefined;
+  readonly docsUrl: string | undefined;
+  readonly authMethods: AuthMethods;
+  readonly resolveRuntimeConfig: RuntimeConfigResolver<AuthMethods> | undefined;
+}
+/** @since 0.0.0 @category type-level */
+export type AddAuthMethods<Self extends Any, AddedMethods extends readonly Any$1[]> = Self extends AiProvider<infer Identifier, infer AuthMethods> ? AiProvider<Identifier, readonly [...AuthMethods, ...AddedMethods]> : never;
+/** @since 0.0.0 @category constructors */
+export declare const make: <const Identifier extends string>(identifier: Identifier) => AiProvider<Identifier>;
+/** @since 0.0.0 @category registry */
+export declare const registryId: (identifier: string) => string;
+/** @since 0.0.0 @category guards */
+export declare const isAiProvider: (value: unknown) => value is Any;
+/** @since 0.0.0 @category combinators */
+export declare const withName: {
+  (name: string): <P extends AiProvider<any, any>>(provider: P) => P;
+  <P extends AiProvider<any, any>>(provider: P, name: string): P;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withDescription: {
+  (description: string): <P extends AiProvider<any, any>>(provider: P) => P;
+  <P extends AiProvider<any, any>>(provider: P, description: string): P;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withIconUrl: {
+  (iconUrl: string): <P extends AiProvider<any, any>>(provider: P) => P;
+  <P extends AiProvider<any, any>>(provider: P, iconUrl: string): P;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withIconUrlDark: {
+  (iconUrlDark: string): <P extends AiProvider<any, any>>(provider: P) => P;
+  <P extends AiProvider<any, any>>(provider: P, iconUrlDark: string): P;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withCategories: {
+  (categories: readonly Category[]): <P extends AiProvider<any, any>>(provider: P) => P;
+  <P extends AiProvider<any, any>>(provider: P, categories: readonly Category[]): P;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withHomepageUrl: {
+  (homepageUrl: string): <P extends AiProvider<any, any>>(provider: P) => P;
+  <P extends AiProvider<any, any>>(provider: P, homepageUrl: string): P;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withDocsUrl: {
+  (docsUrl: string): <P extends AiProvider<any, any>>(provider: P) => P;
+  <P extends AiProvider<any, any>>(provider: P, docsUrl: string): P;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withAuthMethods: {
+  <const AddedMethods extends readonly Any$1[]>(methods: AddedMethods): <Self extends Any>(provider: Self) => AddAuthMethods<Self, AddedMethods>;
+  <Self extends Any, const AddedMethods extends readonly Any$1[]>(provider: Self, methods: AddedMethods): AddAuthMethods<Self, AddedMethods>;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withAuthMethod: {
+  <const AddedMethod extends Any$1>(method: AddedMethod): <Self extends Any>(provider: Self) => AddAuthMethods<Self, readonly [AddedMethod]>;
+  <Self extends Any, const AddedMethod extends Any$1>(provider: Self, method: AddedMethod): AddAuthMethods<Self, readonly [AddedMethod]>;
+};
+/** @since 0.0.0 @category combinators */
+export declare const withRuntimeConfig: {
+  <Self extends Any>(resolve: RuntimeConfigResolver<Self["authMethods"]>): (provider: Self) => Self;
+  <Self extends Any>(provider: Self, resolve: RuntimeConfigResolver<Self["authMethods"]>): Self;
+};
+//#endregion
+export { AiProvider_d_exports };
+//# sourceMappingURL=AiProvider.d.ts.map

package/dist/AiProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AiProvider.d.ts","names":["AuthMethod.Any","AuthMethodBinding.BindingFor"],"sources":["../src/AiProvider.ts"],"mappings":";;;;;;;;qBAqBa;;YAED,gBAAgB;;iBAGX,YAAY,SAAS;YAC1B,SAAS;WACV;WACA;WACA;WACA;WACA;WACA,qBAAqB;WACrB;WACA;WACA,sBAAsBA;WACtB;;;qBAIE,eAAa,OAAA;;;;;;;YAQd,uBAAuB,cAAc;;iBAGhC;WACN;WACA;;;iBAIM,2BAA2B,yBAAyBA;WAC1D,OAAO;WACP,SAASC,WAA6B;;;YAIrC,sBAAsB,yBAAyBD,YACzD,OAAO,2BAA2B,aAC/B;;iBAGY,kBAAkB;WACxB,YAAY;WACZ;WACA;WACA;WACA;WACA,sBAAsB;WACtB;WACA;;;iBAIM,eACX,wCACA,6BAA6BA,+BAEzB,SAAS;YACP,SAAS;WACV,YAAY;WACZ;WACA;WACA;WACA;WACA,qBAAqB;WACrB;WACA;WACA,aAAa;WACb,sBAAsB,sBAAsB;;;YAI3C,eAAe,aAAa,KAAK,8BAA8BA,WACzE,aAAa,iBAAiB,kBAAkB,eAC5C,WAAW,yBAAyB,gBAAgB;;qBAuC7C,aAAc,2BAAyB,YACtC,eACX,WAAW;;qBAGD,aAAU;;qBAGV,eAAY,mBAAqB,SAAS;;qBAa1C;GACV,gBAAgB,UAAU,sBAAsB,UAAU,MAAM;GAChE,UAAU,sBAAsB,UAAU,GAAG,eAAe;;;qBAIlD;GACV,uBAAuB,UAAU,sBAAsB,UAAU,MAAM;GACvE,UAAU,sBAAsB,UAAU,GAAG,sBAAsB;;;qBAMzD;GACV,mBAAmB,UAAU,sBAAsB,UAAU,MAAM;GACnE,UAAU,sBAAsB,UAAU,GAAG,kBAAkB;;;qBAMrD;GACV,uBAAuB,UAAU,sBAAsB,UAAU,MAAM;GACvE,UAAU,sBAAsB,UAAU,GAAG,sBAAsB;;;qBAMzD;GACV,qBAAqB,cAAc,UAAU,sBAAsB,UAAU,MAAM;GACnF,UAAU,sBAAsB,UAAU,GAAG,qBAAqB,aAAa;;;qBAMrE;GACV,uBAAuB,UAAU,sBAAsB,UAAU,MAAM;GACvE,UAAU,sBAAsB,UAAU,GAAG,sBAAsB;;;qBAMzD;GACV,mBAAmB,UAAU,sBAAsB,UAAU,MAAM;GACnE,UAAU,sBAAsB,UAAU,GAAG,kBAAkB;;;qBAMrD;SACJ,8BAA8BA,SACnC,SAAS,gBACP,aAAa,KAAK,UAAU,SAAS,eAAe,MAAM;GAC7D,aAAa,WAAW,8BAA8BA,SACrD,UAAU,MACV,SAAS,eACR,eAAe,MAAM;;;qBAWb;SACJ,oBAAoBA,OACzB,QAAQ,eACN,aAAa,KAAK,UAAU,SAAS,eAAe,gBAAgB;GACvE,aAAa,WAAW,oBAAoBA,OAC3C,UAAU,MACV,QAAQ,cACP,eAAe,gBAAgB;;;qBAMvB;GACV,aAAa,KAAK,SAAS,sBAAsB,wBAAwB,UAAU,SAAS;GAC5F,aAAa,KAAK,UAAU,MAAM,SAAS,sBAAsB,uBAAuB"}

package/dist/AiProvider.js

@@ -0,0 +1,100 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { validateIdentifier } from "./internal/identifier.js";
+import { PipeableProto } from "./internal/proto.js";
+import { assertNoDuplicateAuthMethodIdentifiers } from "./internal/auth-runtime.js";
+import { appendElements } from "./internal/collection-utils.js";
+import { Function, Predicate, Schema } from "effect";
+//#region src/AiProvider.ts
+var AiProvider_exports = /* @__PURE__ */ __exportAll({
+	RuntimeConfig: () => RuntimeConfig,
+	TypeId: () => TypeId,
+	isAiProvider: () => isAiProvider,
+	make: () => make,
+	registryId: () => registryId,
+	withAuthMethod: () => withAuthMethod,
+	withAuthMethods: () => withAuthMethods,
+	withCategories: () => withCategories,
+	withDescription: () => withDescription,
+	withDocsUrl: () => withDocsUrl,
+	withHomepageUrl: () => withHomepageUrl,
+	withIconUrl: () => withIconUrl,
+	withIconUrlDark: () => withIconUrlDark,
+	withName: () => withName,
+	withRuntimeConfig: () => withRuntimeConfig
+});
+/** @since 0.0.0 @category type ids */
+const TypeId = "@dual-os/sdk/AiProvider";
+/** @since 0.0.0 @category models */
+const RuntimeConfig = Schema.Struct({
+	apiKey: Schema.optional(Schema.String),
+	baseUrl: Schema.optional(Schema.String),
+	env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+	headers: Schema.optional(Schema.Record(Schema.String, Schema.NullOr(Schema.String)))
+});
+const optionsFromProvider = (provider) => ({
+	identifier: provider.identifier,
+	...provider.name === void 0 ? {} : { name: provider.name },
+	...provider.description === void 0 ? {} : { description: provider.description },
+	...provider.iconUrl === void 0 ? {} : { iconUrl: provider.iconUrl },
+	...provider.iconUrlDark === void 0 ? {} : { iconUrlDark: provider.iconUrlDark },
+	...provider.categories.length === 0 ? {} : { categories: provider.categories },
+	...provider.homepageUrl === void 0 ? {} : { homepageUrl: provider.homepageUrl },
+	...provider.docsUrl === void 0 ? {} : { docsUrl: provider.docsUrl }
+});
+const Proto = {
+	...PipeableProto,
+	[TypeId]: TypeId
+};
+const makeProvider = (options, authMethods, resolveRuntimeConfig) => {
+	validateIdentifier("provider", options.identifier);
+	assertNoDuplicateAuthMethodIdentifiers(options.identifier, authMethods);
+	return Object.assign(Object.create(Proto), {
+		authMethods,
+		categories: options.categories ?? [],
+		description: options.description,
+		docsUrl: options.docsUrl,
+		homepageUrl: options.homepageUrl,
+		iconUrl: options.iconUrl,
+		iconUrlDark: options.iconUrlDark,
+		identifier: options.identifier,
+		name: options.name,
+		resolveRuntimeConfig
+	});
+};
+/** @since 0.0.0 @category constructors */
+const make = (identifier) => makeProvider({ identifier }, []);
+/** @since 0.0.0 @category registry */
+const registryId = (identifier) => `ai/${identifier}`;
+/** @since 0.0.0 @category guards */
+const isAiProvider = (value) => Predicate.hasProperty(value, TypeId);
+const withOption = (provider, options) => makeProvider({
+	...optionsFromProvider(provider),
+	...options
+}, provider.authMethods, provider.resolveRuntimeConfig);
+/** @since 0.0.0 @category combinators */
+const withName = Function.dual(2, (provider, name) => withOption(provider, { name }));
+/** @since 0.0.0 @category combinators */
+const withDescription = Function.dual(2, (provider, description) => withOption(provider, { description }));
+/** @since 0.0.0 @category combinators */
+const withIconUrl = Function.dual(2, (provider, iconUrl) => withOption(provider, { iconUrl }));
+/** @since 0.0.0 @category combinators */
+const withIconUrlDark = Function.dual(2, (provider, iconUrlDark) => withOption(provider, { iconUrlDark }));
+/** @since 0.0.0 @category combinators */
+const withCategories = Function.dual(2, (provider, categories) => withOption(provider, { categories: [...categories] }));
+/** @since 0.0.0 @category combinators */
+const withHomepageUrl = Function.dual(2, (provider, homepageUrl) => withOption(provider, { homepageUrl }));
+/** @since 0.0.0 @category combinators */
+const withDocsUrl = Function.dual(2, (provider, docsUrl) => withOption(provider, { docsUrl }));
+/** @since 0.0.0 @category combinators */
+const withAuthMethods = Function.dual(2, (provider, methods) => {
+	if (provider.resolveRuntimeConfig !== void 0) throw new Error(`AI provider "${provider.identifier}" must declare auth methods before its runtime config`);
+	return makeProvider(optionsFromProvider(provider), appendElements(provider.authMethods, methods));
+});
+/** @since 0.0.0 @category combinators */
+const withAuthMethod = Function.dual(2, (provider, method) => withAuthMethods(provider, [method]));
+/** @since 0.0.0 @category combinators */
+const withRuntimeConfig = Function.dual(2, (provider, resolve) => makeProvider(optionsFromProvider(provider), provider.authMethods, resolve));
+//#endregion
+export { AiProvider_exports, RuntimeConfig, TypeId, isAiProvider, make, registryId, withAuthMethod, withAuthMethods, withCategories, withDescription, withDocsUrl, withHomepageUrl, withIconUrl, withIconUrlDark, withName, withRuntimeConfig };
+
+//# sourceMappingURL=AiProvider.js.map

package/dist/AiProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AiProvider.js","names":["Func"],"sources":["../src/AiProvider.ts"],"sourcesContent":["/**\n * AI provider definitions for model authentication.\n *\n * AI providers share provider metadata and auth methods with Tools providers,\n * but cannot contribute actions, triggers, or groups. Their identifier is a\n * stable key matched exactly against Pi's `Model.provider` value.\n *\n * @since 0.0.0\n */\nimport type { Pipeable } from \"effect\";\nimport { Function as Func, Predicate, Schema } from \"effect\";\n\nimport type * as AuthMethod from \"./AuthMethod.ts\";\nimport type * as AuthMethodBinding from \"./AuthMethodBinding.ts\";\nimport { assertNoDuplicateAuthMethodIdentifiers } from \"./internal/auth-runtime.ts\";\nimport { appendElements } from \"./internal/collection-utils.ts\";\nimport { validateIdentifier } from \"./internal/identifier.ts\";\nimport { PipeableProto } from \"./internal/proto.ts\";\nimport type { Category } from \"./Plugin.ts\";\n\n/** @since 0.0.0 @category type ids */\nexport const TypeId = \"@dual-os/sdk/AiProvider\" 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 iconUrl: string | undefined;\n  readonly iconUrlDark: string | undefined;\n  readonly categories: readonly Category[];\n  readonly homepageUrl: string | undefined;\n  readonly docsUrl: string | undefined;\n  readonly authMethods: readonly AuthMethod.Any[];\n  readonly resolveRuntimeConfig: unknown;\n}\n\n/** @since 0.0.0 @category models */\nexport const RuntimeConfig = Schema.Struct({\n  apiKey: Schema.optional(Schema.String),\n  baseUrl: Schema.optional(Schema.String),\n  env: Schema.optional(Schema.Record(Schema.String, Schema.String)),\n  headers: Schema.optional(Schema.Record(Schema.String, Schema.NullOr(Schema.String))),\n});\n\n/** @since 0.0.0 @category models */\nexport type RuntimeConfig = typeof RuntimeConfig.Type;\n\n/** @since 0.0.0 @category models */\nexport interface RuntimeModel {\n  readonly id: string;\n  readonly baseUrl: string;\n}\n\n/** @since 0.0.0 @category models */\nexport interface RuntimeConfigResolverInput<Methods extends readonly AuthMethod.Any[]> {\n  readonly model: RuntimeModel;\n  readonly binding: AuthMethodBinding.BindingFor<Methods>;\n}\n\n/** @since 0.0.0 @category models */\nexport type RuntimeConfigResolver<Methods extends readonly AuthMethod.Any[]> = (\n  input: RuntimeConfigResolverInput<Methods>,\n) => RuntimeConfig;\n\n/** @since 0.0.0 @category models */\nexport interface AiProviderOptions<Identifier extends string = string> {\n  readonly identifier: Identifier;\n  readonly name?: string;\n  readonly description?: string;\n  readonly iconUrl?: string;\n  readonly iconUrlDark?: string;\n  readonly categories?: readonly Category[];\n  readonly homepageUrl?: string;\n  readonly docsUrl?: string;\n}\n\n/** @since 0.0.0 @category models */\nexport interface AiProvider<\n  out Identifier extends string = string,\n  out AuthMethods extends readonly AuthMethod.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 iconUrl: string | undefined;\n  readonly iconUrlDark: string | undefined;\n  readonly categories: readonly Category[];\n  readonly homepageUrl: string | undefined;\n  readonly docsUrl: string | undefined;\n  readonly authMethods: AuthMethods;\n  readonly resolveRuntimeConfig: RuntimeConfigResolver<AuthMethods> | undefined;\n}\n\n/** @since 0.0.0 @category type-level */\nexport type AddAuthMethods<Self extends Any, AddedMethods extends readonly AuthMethod.Any[]> =\n  Self extends AiProvider<infer Identifier, infer AuthMethods>\n    ? AiProvider<Identifier, readonly [...AuthMethods, ...AddedMethods]>\n    : never;\n\nconst optionsFromProvider = (provider: Any): AiProviderOptions => ({\n  identifier: provider.identifier,\n  ...(provider.name === undefined ? {} : { name: provider.name }),\n  ...(provider.description === undefined ? {} : { description: provider.description }),\n  ...(provider.iconUrl === undefined ? {} : { iconUrl: provider.iconUrl }),\n  ...(provider.iconUrlDark === undefined ? {} : { iconUrlDark: provider.iconUrlDark }),\n  ...(provider.categories.length === 0 ? {} : { categories: provider.categories }),\n  ...(provider.homepageUrl === undefined ? {} : { homepageUrl: provider.homepageUrl }),\n  ...(provider.docsUrl === undefined ? {} : { docsUrl: provider.docsUrl }),\n});\n\nconst Proto = { ...PipeableProto, [TypeId]: TypeId };\n\nconst makeProvider = <Identifier extends string, AuthMethods extends readonly AuthMethod.Any[]>(\n  options: AiProviderOptions<Identifier>,\n  authMethods: AuthMethods,\n  resolveRuntimeConfig?: RuntimeConfigResolver<AuthMethods>,\n): AiProvider<Identifier, AuthMethods> => {\n  validateIdentifier(\"provider\", options.identifier);\n  assertNoDuplicateAuthMethodIdentifiers(options.identifier, authMethods);\n\n  return Object.assign(Object.create(Proto), {\n    authMethods,\n    categories: options.categories ?? [],\n    description: options.description,\n    docsUrl: options.docsUrl,\n    homepageUrl: options.homepageUrl,\n    iconUrl: options.iconUrl,\n    iconUrlDark: options.iconUrlDark,\n    identifier: options.identifier,\n    name: options.name,\n    resolveRuntimeConfig,\n  });\n};\n\n/** @since 0.0.0 @category constructors */\nexport const make = <const Identifier extends string>(\n  identifier: Identifier,\n): AiProvider<Identifier> => makeProvider({ identifier }, [] as const);\n\n/** @since 0.0.0 @category registry */\nexport const registryId = (identifier: string): string => `ai/${identifier}`;\n\n/** @since 0.0.0 @category guards */\nexport const isAiProvider = (value: unknown): value is Any => Predicate.hasProperty(value, TypeId);\n\nconst withOption = <P extends AiProvider<any, any>>(\n  provider: P,\n  options: Partial<AiProviderOptions>,\n): P =>\n  makeProvider(\n    { ...optionsFromProvider(provider), ...options },\n    provider.authMethods,\n    provider.resolveRuntimeConfig,\n  ) as P;\n\n/** @since 0.0.0 @category combinators */\nexport const withName: {\n  (name: string): <P extends AiProvider<any, any>>(provider: P) => P;\n  <P extends AiProvider<any, any>>(provider: P, name: string): P;\n} = Func.dual(2, (provider: AiProvider<any, any>, name: string) => withOption(provider, { name }));\n\n/** @since 0.0.0 @category combinators */\nexport const withDescription: {\n  (description: string): <P extends AiProvider<any, any>>(provider: P) => P;\n  <P extends AiProvider<any, any>>(provider: P, description: string): P;\n} = Func.dual(2, (provider: AiProvider<any, any>, description: string) =>\n  withOption(provider, { description }),\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withIconUrl: {\n  (iconUrl: string): <P extends AiProvider<any, any>>(provider: P) => P;\n  <P extends AiProvider<any, any>>(provider: P, iconUrl: string): P;\n} = Func.dual(2, (provider: AiProvider<any, any>, iconUrl: string) =>\n  withOption(provider, { iconUrl }),\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withIconUrlDark: {\n  (iconUrlDark: string): <P extends AiProvider<any, any>>(provider: P) => P;\n  <P extends AiProvider<any, any>>(provider: P, iconUrlDark: string): P;\n} = Func.dual(2, (provider: AiProvider<any, any>, iconUrlDark: string) =>\n  withOption(provider, { iconUrlDark }),\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withCategories: {\n  (categories: readonly Category[]): <P extends AiProvider<any, any>>(provider: P) => P;\n  <P extends AiProvider<any, any>>(provider: P, categories: readonly Category[]): P;\n} = Func.dual(2, (provider: AiProvider<any, any>, categories: readonly Category[]) =>\n  withOption(provider, { categories: [...categories] }),\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withHomepageUrl: {\n  (homepageUrl: string): <P extends AiProvider<any, any>>(provider: P) => P;\n  <P extends AiProvider<any, any>>(provider: P, homepageUrl: string): P;\n} = Func.dual(2, (provider: AiProvider<any, any>, homepageUrl: string) =>\n  withOption(provider, { homepageUrl }),\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withDocsUrl: {\n  (docsUrl: string): <P extends AiProvider<any, any>>(provider: P) => P;\n  <P extends AiProvider<any, any>>(provider: P, docsUrl: string): P;\n} = Func.dual(2, (provider: AiProvider<any, any>, docsUrl: string) =>\n  withOption(provider, { docsUrl }),\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withAuthMethods: {\n  <const AddedMethods extends readonly AuthMethod.Any[]>(\n    methods: AddedMethods,\n  ): <Self extends Any>(provider: Self) => AddAuthMethods<Self, AddedMethods>;\n  <Self extends Any, const AddedMethods extends readonly AuthMethod.Any[]>(\n    provider: Self,\n    methods: AddedMethods,\n  ): AddAuthMethods<Self, AddedMethods>;\n} = Func.dual(2, (provider: Any, methods: readonly AuthMethod.Any[]) => {\n  if (provider.resolveRuntimeConfig !== undefined) {\n    throw new Error(\n      `AI provider \"${provider.identifier}\" must declare auth methods before its runtime config`,\n    );\n  }\n  return makeProvider(optionsFromProvider(provider), appendElements(provider.authMethods, methods));\n});\n\n/** @since 0.0.0 @category combinators */\nexport const withAuthMethod: {\n  <const AddedMethod extends AuthMethod.Any>(\n    method: AddedMethod,\n  ): <Self extends Any>(provider: Self) => AddAuthMethods<Self, readonly [AddedMethod]>;\n  <Self extends Any, const AddedMethod extends AuthMethod.Any>(\n    provider: Self,\n    method: AddedMethod,\n  ): AddAuthMethods<Self, readonly [AddedMethod]>;\n} = Func.dual(2, (provider: Any, method: AuthMethod.Any) =>\n  withAuthMethods(provider, [method] as const),\n);\n\n/** @since 0.0.0 @category combinators */\nexport const withRuntimeConfig: {\n  <Self extends Any>(resolve: RuntimeConfigResolver<Self[\"authMethods\"]>): (provider: Self) => Self;\n  <Self extends Any>(provider: Self, resolve: RuntimeConfigResolver<Self[\"authMethods\"]>): Self;\n} = Func.dual(\n  2,\n  (provider: AiProvider<any, any>, resolve: RuntimeConfigResolver<readonly AuthMethod.Any[]>) =>\n    makeProvider(optionsFromProvider(provider), provider.authMethods, resolve),\n);\n"],"mappings":"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"}

package/dist/AuthMethod.d.ts

@@ -0,0 +1,381 @@
+import { OAuth2TokenRefresher_d_exports, Service } from "./OAuth2TokenRefresher.js";
+import { Binding, BindingFor, BindingForMethod, Context, MatchCases, isBindingForMethod, makeBinding } from "./AuthMethodBinding.js";
+import { decodeInput, decodeMaterial, decodeSetup, decodeValue, display, prepare, prepareDecoded, prepareOAuth2Tokens, prepareUnknown, refreshDecoded, refreshUnknown, resolve, resolveDecoded, resolveUnknown, test } from "./AuthMethodExecution.js";
+import { Config, Effect, Pipeable, Schema } from "effect";
+import * as Types from "effect/Types";
+declare namespace AuthMethod_d_exports {
+  export { Any, AuthMethod, AuthMethodHookError, AuthMethodHookOperation, AuthMethodKind, AuthMethodOptions, AuthOptionsWithMaterial, AuthOptionsWithoutMaterial, Binding, BindingFor, BindingForMethod, Context, Display, DisplayHook, ExpectedOAuth2MethodError, FormOptions, HookContext, Input, InputSchema, MatchCases, Material, MaterialSchema, MaybeEffect, OAuth2Client, OAuth2ClientConfig, OAuth2ClientHook, OAuth2Endpoint, OAuth2EndpointHook, OAuth2Headers, OAuth2HeadersHook, OAuth2Options, OAuth2Params, OAuth2ParamsHook, OAuth2ProviderTokenResponse, OAuth2RefreshTokenUnavailableError, OAuth2Setup, OAuth2TokenMaterial, OAuth2TokenRefresher_d_exports as OAuth2TokenRefresher, OAuth2TokenResponse, PrepareHook, RefreshContext, RefreshHook, RefreshReason, Requirements, RequirementsVariance, ResolveHook, SchemaType, Service, Setup, SetupSchema, TestHook, TestResult, TypeId, Value, ValueSchema, auth, decodeInput, decodeMaterial, decodeSetup, decodeValue, display, form, isAuthMethod, isBindingForMethod, make, makeBinding, oauth2, prepare, prepareDecoded, prepareOAuth2Tokens, prepareUnknown, refreshDecoded, refreshUnknown, resolve, resolveDecoded, resolveUnknown, test };
+}
+/**
+ * @since 0.0.0
+ * @category type ids
+ */
+export declare const TypeId: "@dual-os/sdk/AuthMethod";
+/**
+ * @since 0.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId;
+/**
+ * Phantom inference slot for the hook requirements union.
+ *
+ * Unlike the schema parameters, hook requirements only occur inside optional
+ * hook signatures, which TypeScript cannot reliably infer through; this slot
+ * gives the {@link Requirements} extractor a stable inference site.
+ *
+ * One union instead of per-hook parameters on purpose: in practice a method's
+ * dependencies are provided once at the plugin/app definition (for example a
+ * Gmail client layer), not separately per hook, and every consumption path
+ * (invoke, trigger phases, credential lifecycle, `DualRuntime.toLayer`) must demand
+ * the same set so none of them can silently under-require.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface RequirementsVariance<out Requirements> {
+  readonly _Requirements: Types.Covariant<Requirements>;
+}
+/**
+ * Constraint type for working with any {@link AuthMethod}.
+ *
+ * @since 0.0.0
+ * @category type-level
+ */
+export interface Any extends Pipeable.Pipeable {
+  readonly [TypeId]: RequirementsVariance<any>;
+  readonly identifier: string;
+  readonly name: string | undefined;
+  readonly description: string | undefined;
+  readonly kind: AuthMethodKind;
+  readonly setup: Schema.Top | undefined;
+  readonly input: Schema.Top | undefined;
+  readonly material: Schema.Top;
+  readonly value: Schema.Top;
+  readonly schema: Schema.Top;
+  readonly prepare: unknown;
+  readonly refresh: unknown;
+  readonly resolve: unknown;
+  readonly display: unknown;
+  readonly test: unknown;
+  readonly oauth2: OAuth2Setup<Schema.Top, any, any> | undefined;
+}
+/** @since 0.0.0 @category models */
+export type AuthMethodKind = "form" | "oauth2" | "custom";
+/** @since 0.0.0 @category type-level */
+export type SchemaType<SchemaDef extends Schema.Top | undefined> = SchemaDef extends Schema.Top ? Schema.Schema.Type<SchemaDef> : undefined;
+/** @since 0.0.0 @category hooks */
+export interface HookContext<Setup = undefined> {
+  readonly setup: Setup;
+}
+/** @since 0.0.0 @category hooks */
+export type MaybeEffect<Value, Error = never, Requirements = never> = Value | Effect.Effect<Value, Error, Requirements>;
+/** @since 0.0.0 @category hooks */
+export type PrepareHook<Input, Material, Error = never, Requirements = never, Setup = undefined> = (input: Input, context: HookContext<Setup>) => MaybeEffect<Material, Error, Requirements>;
+/** @since 0.0.0 @category hooks */
+export type RefreshReason = "before-use" | "forced";
+/** @since 0.0.0 @category hooks */
+export interface RefreshContext<Setup = undefined> extends HookContext<Setup> {
+  readonly now: number;
+  readonly minValidityMs: number;
+  readonly reason: RefreshReason;
+}
+/** @since 0.0.0 @category hooks */
+export type RefreshHook<Material, Error = never, Requirements = never, Setup = undefined> = (material: Material, context: RefreshContext<Setup>) => MaybeEffect<Material | undefined, Error, Requirements>;
+/** @since 0.0.0 @category hooks */
+export type ResolveHook<Material, Value, Error = never, Requirements = never, Setup = undefined> = (material: Material, context: HookContext<Setup>) => MaybeEffect<Value, Error, Requirements>;
+/** @since 0.0.0 @category models */
+export interface Display {
+  readonly label?: string;
+  readonly description?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+/** @since 0.0.0 @category hooks */
+export type DisplayHook<Material, Error = never, Requirements = never, Setup = undefined> = (material: Material, context: HookContext<Setup>) => MaybeEffect<Display, Error, Requirements>;
+/** @since 0.0.0 @category models */
+export interface TestResult {
+  readonly ok: boolean;
+  readonly message?: string;
+}
+declare const ExpectedOAuth2MethodError_base: Schema.Class<ExpectedOAuth2MethodError, Schema.TaggedStruct<"ExpectedOAuth2MethodError", {
+  readonly methodIdentifier: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** @since 0.0.0 @category errors */
+export declare class ExpectedOAuth2MethodError extends ExpectedOAuth2MethodError_base {}
+/** @since 0.0.0 @category hooks */
+export type TestHook<Material, Error = never, Requirements = never, Setup = undefined> = (material: Material, context: HookContext<Setup>) => MaybeEffect<TestResult, Error, Requirements>;
+/**
+ * Options used to create an {@link AuthMethod}.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface AuthMethodOptions<ValueSchema extends Schema.Top> {
+  readonly name?: string;
+  readonly description?: string;
+  readonly schema: ValueSchema;
+}
+/** @since 0.0.0 @category models */
+export interface FormOptions<ValueSchema extends Schema.Top, SetupSchema extends Schema.Top | undefined = undefined> extends AuthMethodOptions<ValueSchema> {
+  readonly setup?: SetupSchema;
+}
+/** @since 0.0.0 @category models */
+export interface AuthOptionsWithoutMaterial<InputSchema extends Schema.Top, ValueSchema extends Schema.Top = InputSchema, SetupSchema extends Schema.Top | undefined = undefined, PrepareRequirements = never, RefreshRequirements = never, ResolveRequirements = never, DisplayRequirements = never, TestRequirements = never> {
+  readonly name?: string;
+  readonly description?: string;
+  readonly setup?: SetupSchema;
+  readonly input: InputSchema;
+  readonly material?: undefined;
+  readonly value?: ValueSchema;
+  readonly prepare?: PrepareHook<SchemaType<InputSchema>, SchemaType<InputSchema>, any, PrepareRequirements, SchemaType<SetupSchema>>;
+  readonly refresh?: RefreshHook<SchemaType<InputSchema>, any, RefreshRequirements, SchemaType<SetupSchema>>;
+  readonly resolve?: ResolveHook<SchemaType<InputSchema>, Schema.Schema.Type<ValueSchema>, any, ResolveRequirements, SchemaType<SetupSchema>>;
+  readonly display?: DisplayHook<SchemaType<InputSchema>, any, DisplayRequirements, SchemaType<SetupSchema>>;
+  readonly test?: TestHook<SchemaType<InputSchema>, any, TestRequirements, SchemaType<SetupSchema>>;
+}
+/** @since 0.0.0 @category models */
+export interface AuthOptionsWithMaterial<InputSchema extends Schema.Top | undefined, MaterialSchema extends Schema.Top, ValueSchema extends Schema.Top = MaterialSchema, SetupSchema extends Schema.Top | undefined = undefined, PrepareRequirements = never, RefreshRequirements = never, ResolveRequirements = never, DisplayRequirements = never, TestRequirements = never> {
+  readonly name?: string;
+  readonly description?: string;
+  readonly setup?: SetupSchema;
+  readonly input: InputSchema;
+  readonly material: MaterialSchema;
+  readonly value?: ValueSchema;
+  readonly prepare?: PrepareHook<SchemaType<InputSchema>, Schema.Schema.Type<MaterialSchema>, any, PrepareRequirements, SchemaType<SetupSchema>>;
+  readonly refresh?: RefreshHook<Schema.Schema.Type<MaterialSchema>, any, RefreshRequirements, SchemaType<SetupSchema>>;
+  readonly resolve?: ResolveHook<Schema.Schema.Type<MaterialSchema>, Schema.Schema.Type<ValueSchema>, any, ResolveRequirements, SchemaType<SetupSchema>>;
+  readonly display?: DisplayHook<Schema.Schema.Type<MaterialSchema>, any, DisplayRequirements, SchemaType<SetupSchema>>;
+  readonly test?: TestHook<Schema.Schema.Type<MaterialSchema>, any, TestRequirements, SchemaType<SetupSchema>>;
+}
+/** @since 0.0.0 @category models */
+export interface OAuth2ClientConfig {
+  readonly clientId: string | Config.Config<string>;
+  readonly clientSecret?: string | Config.Config<string>;
+  readonly authentication?: "basic" | "post" | "none";
+}
+/** @since 0.0.0 @category hooks */
+export type OAuth2ClientHook<Setup> = (context: HookContext<Setup>) => OAuth2ClientConfig;
+/** @since 0.0.0 @category models */
+export type OAuth2Client<Setup = undefined> = OAuth2ClientConfig | OAuth2ClientHook<Setup>;
+/** @since 0.0.0 @category hooks */
+export type OAuth2EndpointHook<Setup> = (context: HookContext<Setup>) => string;
+/**
+ * An OAuth2 endpoint, fixed or derived from the setup.
+ *
+ * Providers that host one instance per customer — a Microsoft tenant, a
+ * self-hosted GitLab — cannot name their endpoints until the connection's setup
+ * says which instance it is.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export type OAuth2Endpoint<Setup = undefined> = string | OAuth2EndpointHook<Setup>;
+/** @since 0.0.0 @category models */
+export type OAuth2ParamsHook<Setup> = (context: HookContext<Setup>) => Readonly<Record<string, string>>;
+/**
+ * Query parameters added to the authorization or token request, fixed or
+ * derived from the setup — the same freedom the endpoints have. A provider
+ * that knows which account a connection is for can say so in the request
+ * instead of leaving the choice to whatever session the browser carries.
+ *
+ * @since 0.0.0 @category models
+ */
+export type OAuth2Params<Setup = undefined> = Readonly<Record<string, string>> | OAuth2ParamsHook<Setup>;
+/** @since 0.0.0 @category hooks */
+export type OAuth2HeadersHook<SetupValue> = (context: HookContext<SetupValue>) => Readonly<Record<string, string>>;
+/**
+ * Provider headers for token exchange and refresh, fixed or derived from setup.
+ * Hosts must reject invalid headers and case-insensitive overrides of client
+ * authentication and transport headers. Keep values out of authorization URLs,
+ * public metadata, logs, and errors.
+ *
+ * @since 0.0.0 @category models
+ */
+export type OAuth2Headers<SetupValue = HookContext["setup"]> = Readonly<Record<string, string>> | OAuth2HeadersHook<SetupValue>;
+/** @since 0.0.0 @category schemas */
+export declare const OAuth2ProviderTokenResponse: Schema.Struct<{
+  readonly access_token: Schema.optional<Schema.String>;
+  readonly expires_at: Schema.optional<Schema.String>;
+  readonly expires_in: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.String]>>;
+  readonly refresh_token: Schema.optional<Schema.String>;
+  readonly scope: Schema.optional<Schema.String>;
+  readonly token_type: Schema.optional<Schema.String>;
+}>;
+/** @since 0.0.0 @category models */
+export type OAuth2ProviderTokenResponse = typeof OAuth2ProviderTokenResponse.Type;
+/** @since 0.0.0 @category schemas */
+export declare const OAuth2TokenResponse: Schema.Struct<{
+  readonly accessToken: Schema.String;
+  readonly expiresAt: Schema.optional<Schema.Number>;
+  readonly expiresIn: Schema.optional<Schema.Number>;
+  readonly raw: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly refreshToken: Schema.optional<Schema.String>;
+  readonly scope: Schema.optional<Schema.String>;
+  readonly tokenType: Schema.optional<Schema.String>;
+}>;
+/** @since 0.0.0 @category models */
+export type OAuth2TokenResponse = typeof OAuth2TokenResponse.Type;
+declare const OAuth2RefreshTokenUnavailableError_base: Schema.Class<OAuth2RefreshTokenUnavailableError, Schema.TaggedStruct<"OAuth2RefreshTokenUnavailableError", {
+  readonly methodIdentifier: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** @since 0.0.0 @category errors */
+export declare class OAuth2RefreshTokenUnavailableError extends OAuth2RefreshTokenUnavailableError_base {}
+/** @since 0.0.0 @category errors */
+export declare const AuthMethodHookOperation: Schema.Literals<readonly ["prepare", "refresh", "prepareOAuth2Tokens", "resolve", "display", "test", "oauth2TokenRefresh"]>;
+/** @since 0.0.0 @category errors */
+export type AuthMethodHookOperation = typeof AuthMethodHookOperation.Type;
+declare const AuthMethodHookError_base: Schema.Class<AuthMethodHookError, Schema.TaggedStruct<"AuthMethodHookError", {
+  readonly cause: Schema.Defect;
+  readonly methodIdentifier: Schema.String;
+  readonly operation: Schema.Literals<readonly ["prepare", "refresh", "prepareOAuth2Tokens", "resolve", "display", "test", "oauth2TokenRefresh"]>;
+}>, import("effect/Cause").YieldableError>;
+/** @since 0.0.0 @category errors */
+export declare class AuthMethodHookError extends AuthMethodHookError_base {}
+/** @since 0.0.0 @category schemas */
+export declare const OAuth2TokenMaterial: Schema.Struct<{
+  readonly accessToken: Schema.String;
+  readonly expiresAt: Schema.optional<Schema.Number>;
+  readonly expiresIn: Schema.optional<Schema.Number>;
+  readonly raw: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly refreshToken: Schema.optional<Schema.String>;
+  readonly scope: Schema.optional<Schema.String>;
+  readonly tokenType: Schema.optional<Schema.String>;
+}>;
+/** @since 0.0.0 @category models */
+export interface OAuth2Setup<MaterialSchema extends Schema.Top, Setup = undefined, TokenRequirements = never> {
+  readonly scopes: readonly string[];
+  readonly client: OAuth2Client<Setup>;
+  readonly discoveryUrl?: OAuth2Endpoint<Setup>;
+  readonly authorizationUrl?: OAuth2Endpoint<Setup>;
+  readonly tokenUrl?: OAuth2Endpoint<Setup>;
+  readonly pkce?: boolean;
+  readonly authorizationParams?: OAuth2Params<Setup>;
+  readonly tokenParams?: OAuth2Params<Setup>;
+  readonly tokenHeaders?: OAuth2Headers<Setup>;
+  /** Token request body encoding. Standard OAuth2 methods use form encoding. */
+  readonly tokenRequestEncoding?: "form" | "json";
+  /** Decode a provider response into the standard token fields before host normalization. */
+  readonly tokenResponse?: Schema.Decoder<OAuth2ProviderTokenResponse>;
+  readonly fromTokens?: PrepareHook<OAuth2TokenResponse, Schema.Schema.Type<MaterialSchema>, any, TokenRequirements, Setup>;
+}
+/** @since 0.0.0 @category models */
+export interface OAuth2Options<MaterialSchema extends Schema.Top, ValueSchema extends Schema.Top = MaterialSchema, SetupSchema extends Schema.Top | undefined = undefined, TokenRequirements = never, ResolveRequirements = never, DisplayRequirements = never, TestRequirements = never> extends OAuth2Setup<MaterialSchema, SchemaType<SetupSchema>, TokenRequirements> {
+  readonly name?: string;
+  readonly description?: string;
+  readonly setup?: SetupSchema;
+  readonly material: MaterialSchema;
+  readonly value?: ValueSchema;
+  readonly fromTokens?: PrepareHook<OAuth2TokenResponse, Schema.Schema.Type<MaterialSchema>, any, TokenRequirements, SchemaType<SetupSchema>>;
+  readonly resolve?: ResolveHook<Schema.Schema.Type<MaterialSchema>, Schema.Schema.Type<ValueSchema>, any, ResolveRequirements, SchemaType<SetupSchema>>;
+  readonly display?: DisplayHook<Schema.Schema.Type<MaterialSchema>, any, DisplayRequirements, SchemaType<SetupSchema>>;
+  readonly test?: TestHook<Schema.Schema.Type<MaterialSchema>, any, TestRequirements, SchemaType<SetupSchema>>;
+}
+/**
+ * A typed provider-owned auth method definition.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface AuthMethod<out Identifier extends string = string, out SetupSchema extends Schema.Top | undefined = Schema.Top | undefined, out InputSchema extends Schema.Top | undefined = Schema.Top | undefined, out MaterialSchema extends Schema.Top = Schema.Top, out ValueSchema extends Schema.Top = Schema.Top, out Requirements = never> extends Pipeable.Pipeable {
+  readonly [TypeId]: RequirementsVariance<Requirements>;
+  readonly identifier: Identifier;
+  readonly name: string | undefined;
+  readonly description: string | undefined;
+  readonly kind: AuthMethodKind;
+  readonly setup: SetupSchema;
+  readonly input: InputSchema;
+  readonly material: MaterialSchema;
+  readonly value: ValueSchema;
+  /** Runtime value schema retained for concise action/trigger typing. */
+  readonly schema: ValueSchema;
+  readonly prepare: PrepareHook<SchemaType<InputSchema>, Schema.Schema.Type<MaterialSchema>, any, Requirements, SchemaType<SetupSchema>> | undefined;
+  readonly refresh: RefreshHook<Schema.Schema.Type<MaterialSchema>, any, Requirements, SchemaType<SetupSchema>> | undefined;
+  readonly resolve: ResolveHook<Schema.Schema.Type<MaterialSchema>, Schema.Schema.Type<ValueSchema>, any, Requirements, SchemaType<SetupSchema>> | undefined;
+  readonly display: DisplayHook<Schema.Schema.Type<MaterialSchema>, any, Requirements, SchemaType<SetupSchema>> | undefined;
+  readonly test: TestHook<Schema.Schema.Type<MaterialSchema>, any, Requirements, SchemaType<SetupSchema>> | undefined;
+  readonly oauth2: OAuth2Setup<MaterialSchema, SchemaType<SetupSchema>, Requirements> | undefined;
+}
+/**
+ * Create an {@link AuthMethod} definition.
+ *
+ * @since 0.0.0
+ * @category constructors
+ */
+export declare const make: <const Identifier extends string, ValueSchema extends Schema.Top, SetupSchema extends Schema.Top | undefined = undefined>(identifier: Identifier, options: FormOptions<ValueSchema, SetupSchema>) => AuthMethod<Identifier, SetupSchema, ValueSchema, ValueSchema, ValueSchema>;
+/**
+ * Create a simple form auth method where input, stored material, and runtime value share one schema.
+ *
+ * @since 0.0.0
+ * @category constructors
+ */
+export declare const form: <const Identifier extends string, ValueSchema extends Schema.Top, SetupSchema extends Schema.Top | undefined = undefined>(identifier: Identifier, options: FormOptions<ValueSchema, SetupSchema>) => AuthMethod<Identifier, SetupSchema, ValueSchema, ValueSchema, ValueSchema>;
+/**
+ * Create a custom auth setup method.
+ *
+ * @since 0.0.0
+ * @category constructors
+ */
+export declare function auth<const Identifier extends string, InputSchema extends Schema.Top, ValueSchema extends Schema.Top = InputSchema, SetupSchema extends Schema.Top | undefined = undefined, PrepareRequirements = never, RefreshRequirements = never, ResolveRequirements = never, DisplayRequirements = never, TestRequirements = never>(identifier: Identifier, options: AuthOptionsWithoutMaterial<InputSchema, ValueSchema, SetupSchema, PrepareRequirements, RefreshRequirements, ResolveRequirements, DisplayRequirements, TestRequirements>): AuthMethod<Identifier, SetupSchema, InputSchema, InputSchema, ValueSchema, PrepareRequirements | RefreshRequirements | ResolveRequirements | DisplayRequirements | TestRequirements>;
+export declare function auth<const Identifier extends string, InputSchema extends Schema.Top | undefined, MaterialSchema extends Schema.Top, ValueSchema extends Schema.Top = MaterialSchema, SetupSchema extends Schema.Top | undefined = undefined, PrepareRequirements = never, RefreshRequirements = never, ResolveRequirements = never, DisplayRequirements = never, TestRequirements = never>(identifier: Identifier, options: AuthOptionsWithMaterial<InputSchema, MaterialSchema, ValueSchema, SetupSchema, PrepareRequirements, RefreshRequirements, ResolveRequirements, DisplayRequirements, TestRequirements>): AuthMethod<Identifier, SetupSchema, InputSchema, MaterialSchema, ValueSchema, PrepareRequirements | RefreshRequirements | ResolveRequirements | DisplayRequirements | TestRequirements>;
+/**
+ * Create an OAuth2 auth method over the same setup primitive.
+ *
+ * OAuth2 has no submitted form input; the platform owns the browser redirect,
+ * callback, state/PKCE, and token exchange before storing mapped material.
+ *
+ * @since 0.0.0
+ * @category constructors
+ */
+export declare const oauth2: <const Identifier extends string, MaterialSchema extends Schema.Top, ValueSchema extends Schema.Top = MaterialSchema, SetupSchema extends Schema.Top | undefined = undefined, TokenRequirements = never, ResolveRequirements = never, DisplayRequirements = never, TestRequirements = never>(identifier: Identifier, options: OAuth2Options<MaterialSchema, ValueSchema, SetupSchema, TokenRequirements, ResolveRequirements, DisplayRequirements, TestRequirements>) => AuthMethod<Identifier, SetupSchema, undefined, MaterialSchema, ValueSchema, Service | Schema.Codec.DecodingServices<MaterialSchema> | TokenRequirements | ResolveRequirements | DisplayRequirements | TestRequirements>;
+/**
+ * Check if a value is an {@link AuthMethod}.
+ *
+ * @since 0.0.0
+ * @category guards
+ */
+export declare const isAuthMethod: (u: unknown) => u is Any;
+/**
+ * Resolved value type carried by a {@link AuthMethod}.
+ *
+ * @since 0.0.0
+ * @category type-level
+ */
+export type Value<Method extends Any> = Schema.Schema.Type<ValueSchema<Method>>;
+/** @since 0.0.0 @category type-level */
+export type Setup<Method extends Any> = SchemaType<SetupSchema<Method>>;
+/**
+ * Submitted setup input type carried by an {@link AuthMethod}.
+ *
+ * @since 0.0.0
+ * @category type-level
+ */
+export type Input<Method extends Any> = SchemaType<InputSchema<Method>>;
+/**
+ * Encrypted stored material type carried by an {@link AuthMethod}.
+ *
+ * @since 0.0.0
+ * @category type-level
+ */
+export type Material<Method extends Any> = Schema.Schema.Type<MaterialSchema<Method>>;
+/**
+ * Schema type carried by a {@link AuthMethod}.
+ *
+ * @since 0.0.0
+ * @category type-level
+ */
+export type ValueSchema<Method extends Any> = Method["value"];
+/** @since 0.0.0 @category type-level */
+export type SetupSchema<Method extends Any> = Method["setup"];
+/** @since 0.0.0 @category type-level */
+export type InputSchema<Method extends Any> = Method["input"];
+/** @since 0.0.0 @category type-level */
+export type MaterialSchema<Method extends Any> = Method["material"];
+/**
+ * Services required by the method's hooks, as one union.
+ *
+ * @since 0.0.0
+ * @category type-level
+ */
+export type Requirements<Method extends Any> = Types.Covariant.Type<Method[TypeId]["_Requirements"]>;
+//#endregion
+export { AuthMethod_d_exports, type Binding, type BindingFor, type BindingForMethod, type Context, type MatchCases, OAuth2TokenRefresher_d_exports as OAuth2TokenRefresher, Service, decodeInput, decodeMaterial, decodeSetup, decodeValue, display, isBindingForMethod, makeBinding, prepare, prepareDecoded, prepareOAuth2Tokens, prepareUnknown, refreshDecoded, refreshUnknown, resolve, resolveDecoded, resolveUnknown, test };
+//# sourceMappingURL=AuthMethod.d.ts.map