effect-start 0.22.0 → 0.23.0

package/dist/BlobStore.d.ts

@@ -0,0 +1,80 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import type * as PlatformError from "./PlatformError.ts";
+export interface BlobInfo {
+    readonly size: number;
+    readonly lastModified: Option.Option<Date>;
+    readonly etag: Option.Option<string>;
+    readonly type: Option.Option<string>;
+}
+export interface BlobRef {
+    readonly key: string;
+    readonly bytes: Effect.Effect<Uint8Array, PlatformError.PlatformError>;
+    readonly text: Effect.Effect<string, PlatformError.PlatformError>;
+    readonly json: Effect.Effect<unknown, PlatformError.PlatformError>;
+    readonly stat: Effect.Effect<BlobInfo, PlatformError.PlatformError>;
+    readonly exists: Effect.Effect<boolean, PlatformError.PlatformError>;
+    readonly delete: Effect.Effect<void, PlatformError.PlatformError>;
+    readonly stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>;
+    readonly write: (data: string | Uint8Array | ArrayBuffer) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly slice: (begin?: number, end?: number) => BlobRef;
+}
+export interface ListEntry {
+    readonly key: string;
+    readonly size: Option.Option<number>;
+    readonly lastModified: Option.Option<Date>;
+    readonly etag: Option.Option<string>;
+}
+export interface ListOptions {
+    readonly prefix?: string;
+}
+export interface PresignOptions {
+    readonly expiresIn?: number;
+    readonly method?: "GET" | "PUT" | "DELETE" | "HEAD";
+}
+declare const BlobStore_base: Context.TagClass<BlobStore, "effect-start/BlobStore", {
+    readonly ref: (key: string) => Effect.Effect<BlobRef, PlatformError.PlatformError>;
+    readonly list: (options?: ListOptions) => Stream.Stream<ListEntry, PlatformError.PlatformError>;
+    readonly presign: (key: string, options?: PresignOptions) => Effect.Effect<string, PlatformError.PlatformError>;
+}>;
+export declare class BlobStore extends BlobStore_base {
+}
+declare const WatchEventCreated_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
+    readonly _tag: "Created";
+};
+export declare class WatchEventCreated extends WatchEventCreated_base<{
+    readonly key: string;
+}> {
+}
+declare const WatchEventUpdated_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
+    readonly _tag: "Updated";
+};
+export declare class WatchEventUpdated extends WatchEventUpdated_base<{
+    readonly key: string;
+}> {
+}
+declare const WatchEventDeleted_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
+    readonly _tag: "Deleted";
+};
+export declare class WatchEventDeleted extends WatchEventDeleted_base<{
+    readonly key: string;
+}> {
+}
+export type WatchEvent = WatchEventCreated | WatchEventUpdated | WatchEventDeleted;
+export interface WatchOptions {
+    readonly prefix?: string;
+}
+declare const BlobWatcher_base: Context.TagClass<BlobWatcher, "effect-start/BlobWatcher", {
+    readonly watch: (options?: WatchOptions) => Stream.Stream<WatchEvent, PlatformError.PlatformError>;
+    readonly notify: (event: WatchEvent) => Effect.Effect<boolean, PlatformError.PlatformError>;
+}>;
+export declare class BlobWatcher extends BlobWatcher_base {
+}
+export declare const watch: (options?: WatchOptions) => Stream.Stream<WatchEvent, PlatformError.PlatformError, BlobWatcher>;
+export declare const notify: (event: WatchEvent) => Effect.Effect<boolean, PlatformError.PlatformError, BlobWatcher>;
+export declare const ref: (key: string) => Effect.Effect<BlobRef, PlatformError.PlatformError, BlobStore>;
+export declare const list: (options?: ListOptions) => Stream.Stream<ListEntry, PlatformError.PlatformError, BlobStore>;
+export declare const presign: (key: string, options?: PresignOptions) => Effect.Effect<string, PlatformError.PlatformError, BlobStore>;
+export {};

package/dist/BlobStore.js

@@ -0,0 +1,19 @@
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+export class BlobStore extends Context.Tag("effect-start/BlobStore")() {
+}
+export class WatchEventCreated extends Data.TaggedClass("Created") {
+}
+export class WatchEventUpdated extends Data.TaggedClass("Updated") {
+}
+export class WatchEventDeleted extends Data.TaggedClass("Deleted") {
+}
+export class BlobWatcher extends Context.Tag("effect-start/BlobWatcher")() {
+}
+export const watch = (options) => Stream.unwrap(Effect.map(BlobWatcher, (watcher) => watcher.watch(options)));
+export const notify = (event) => Effect.flatMap(BlobWatcher, (watcher) => watcher.notify(event));
+export const ref = (key) => Effect.flatMap(BlobStore, (store) => store.ref(key));
+export const list = (options) => Stream.unwrap(Effect.map(BlobStore, (store) => store.list(options)));
+export const presign = (key, options) => Effect.flatMap(BlobStore, (store) => store.presign(key, options));

package/dist/ChildProcess.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Adapted from upcomnig Effect 4 aka effect-smol.
+ *
+ * Kept a minimal interface without tempaltes and file descirptor
+ * to keep it compatible if it lands in the core (ie. not in seperate platform package.)
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Pipeable from "effect/Pipeable";
+import type * as Scope from "effect/Scope";
+import type * as Sink from "effect/Sink";
+import type * as Stream from "effect/Stream";
+import type * as PlatformError from "./PlatformError.ts";
+declare const TypeId: unique symbol;
+type TypeId = typeof TypeId;
+type Stdio = "pipe" | "inherit" | "ignore";
+export interface Command extends Pipeable.Pipeable {
+    readonly [TypeId]: TypeId;
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+    readonly cwd?: string;
+    readonly env?: Record<string, string>;
+    readonly stdin?: Stdio;
+    readonly stdout?: Stdio;
+    readonly stderr?: Stdio;
+    readonly detached?: boolean;
+    [Symbol.iterator](): Effect.EffectGenerator<Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, ChildProcessSpawner | Scope.Scope>>;
+}
+export declare namespace Command {
+    interface Options {
+        readonly cwd?: string;
+        readonly env?: Record<string, string>;
+        readonly stdin?: Stdio;
+        readonly stdout?: Stdio;
+        readonly stderr?: Stdio;
+        readonly detached?: boolean;
+    }
+}
+export declare const isCommand: (u: unknown) => u is Command;
+export declare const make: (command: string, args?: ReadonlyArray<string>, options?: Command.Options) => Command;
+export type Signal = "SIGABRT" | "SIGALRM" | "SIGBUS" | "SIGCHLD" | "SIGCONT" | "SIGFPE" | "SIGHUP" | "SIGILL" | "SIGINT" | "SIGIO" | "SIGIOT" | "SIGKILL" | "SIGPIPE" | "SIGPOLL" | "SIGPROF" | "SIGPWR" | "SIGQUIT" | "SIGSEGV" | "SIGSTKFLT" | "SIGSTOP" | "SIGSYS" | "SIGTERM" | "SIGTRAP" | "SIGTSTP" | "SIGTTIN" | "SIGTTOU" | "SIGUNUSED" | "SIGURG" | "SIGUSR1" | "SIGUSR2" | "SIGVTALRM" | "SIGWINCH" | "SIGXCPU" | "SIGXFSZ" | "SIGBREAK" | "SIGLOST" | "SIGINFO";
+export interface KillOptions {
+    readonly killSignal?: Signal | undefined;
+}
+export interface ChildProcessHandle {
+    readonly pid: number;
+    readonly exitCode: Effect.Effect<number, PlatformError.PlatformError>;
+    readonly isRunning: Effect.Effect<boolean, PlatformError.PlatformError>;
+    readonly kill: (options?: KillOptions) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly stdin: Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>;
+    readonly stdout: Stream.Stream<Uint8Array, PlatformError.PlatformError>;
+    readonly stderr: Stream.Stream<Uint8Array, PlatformError.PlatformError>;
+}
+declare const ChildProcessSpawner_base: Context.TagClass<ChildProcessSpawner, "effect-start/ChildProcessSpawner", {
+    readonly spawn: (command: Command) => Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, Scope.Scope>;
+}>;
+export declare class ChildProcessSpawner extends ChildProcessSpawner_base {
+}
+export declare const spawn: (command: Command) => Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, ChildProcessSpawner | Scope.Scope>;
+export {};

package/dist/ChildProcess.js

@@ -0,0 +1,30 @@
+/**
+ * Adapted from upcomnig Effect 4 aka effect-smol.
+ *
+ * Kept a minimal interface without tempaltes and file descirptor
+ * to keep it compatible if it lands in the core (ie. not in seperate platform package.)
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Pipeable from "effect/Pipeable";
+import * as Predicate from "effect/Predicate";
+import * as Utils from "effect/Utils";
+const TypeId = Symbol.for("effect-start/ChildProcess/Command");
+const CommandProto = {
+    [TypeId]: TypeId,
+    pipe() {
+        return Pipeable.pipeArguments(this, arguments);
+    },
+    [Symbol.iterator]() {
+        return new Utils.SingleShotGen(new Utils.YieldWrap(spawn(this)));
+    },
+};
+export const isCommand = (u) => Predicate.hasProperty(u, TypeId);
+export const make = (command, args, options) => Object.assign(Object.create(CommandProto), {
+    command,
+    args: args ?? [],
+    ...options,
+});
+export class ChildProcessSpawner extends Context.Tag("effect-start/ChildProcessSpawner")() {
+}
+export const spawn = (command) => Effect.flatMap(ChildProcessSpawner, (spawner) => spawner.spawn(command));

package/dist/Commander.d.ts

@@ -50,10 +50,7 @@ export interface SubcommandDef<Handled extends boolean = boolean> {
     readonly _tag: "SubcommandDef";
     readonly command: CommanderSet<any, any, Handled>;
 }
-type Extend<S, NewOpts extends OptionsMap, NewSubs extends ReadonlyArray<SubcommandDef> = [], Handled extends boolean = false> = S extends CommanderSet<infer Opts, infer Subs, infer _H> ? CommanderSet<Opts & NewOpts, [
-    ...Subs,
-    ...NewSubs
-], Handled> : CommanderSet<NewOpts, NewSubs, Handled>;
+type Extend<S, NewOpts extends OptionsMap, NewSubs extends ReadonlyArray<SubcommandDef> = [], Handled extends boolean = false> = S extends CommanderSet<infer Opts, infer Subs, infer _H> ? CommanderSet<Opts & NewOpts, [...Subs, ...NewSubs], Handled> : CommanderSet<NewOpts, NewSubs, Handled>;
 type CommanderBuilder = {
     option: typeof optionMethod;
     optionHelp: typeof optionHelp;
@@ -81,10 +78,10 @@ export declare namespace CommanderSet {
 }
 declare const optionMethod: <S, Opt extends OptionBuilder<any, any>>(this: S, opt: Opt) => Extend<S, { [K in Opt["name"] as OptionNameToCamelCase<K>]: Opt; }>;
 export declare const optionHelp: <S>(this: S) => Extend<S, {
-    "help": OptionBuilder<boolean, "--help">;
+    help: OptionBuilder<boolean, "--help">;
 }>;
 export declare const optionVersion: <S>(this: S) => Extend<S, {
-    "version": OptionBuilder<boolean, "--version">;
+    version: OptionBuilder<boolean, "--version">;
 }>;
 export declare const subcommand: <S, SubOpts extends OptionsMap, SubSubs extends ReadonlyArray<SubcommandDef>, SubHandled extends boolean>(this: S, cmd: CommanderSet<SubOpts, SubSubs, SubHandled>) => Extend<S, {}, [SubcommandDef<SubHandled>]>;
 export declare const handle: <Opts extends OptionsMap, Subs extends ReadonlyArray<SubcommandDef>>(this: CommanderSet<Opts, Subs, false>, handler: (args: ExtractOptionValues<Opts>) => Effect.Effect<void>) => CommanderSet<Opts, Subs, true>;

package/dist/Commander.js

@@ -222,8 +222,7 @@ const parseRawArgs = (args) => Effect.gen(function* () {
             const chars = arg.slice(1);
             for (let j = 0; j < chars.length; j++) {
                 const char = chars[j];
-                if (j === chars.length - 1 && i + 1 < args.length && !args[i + 1]
-                    .startsWith("-")) {
+                if (j === chars.length - 1 && i + 1 < args.length && !args[i + 1].startsWith("-")) {
                     options[char] = args[i + 1];
                     i++;
                 }
@@ -247,7 +246,7 @@ export const parse = (cmd, args) => Effect.gen(function* () {
         const shortName = optBuilder.short;
         const longMatch = parsed.options[longName] || parsed.flags[longName];
         const shortMatch = shortName
-            ? (parsed.options[shortName] || parsed.flags[shortName])
+            ? parsed.options[shortName] || parsed.flags[shortName]
             : undefined;
         const rawValue = longMatch ?? shortMatch;
         const camelKey = kebabToCamel(stripPrefix(optBuilder.long));
@@ -256,9 +255,7 @@ export const parse = (cmd, args) => Effect.gen(function* () {
                 result[camelKey] = rawValue;
             }
             else if (optBuilder.schema) {
-                const decoded = yield* Schema
-                    .decode(optBuilder.schema)(rawValue)
-                    .pipe(Effect.mapError((error) => new CommanderError({
+                const decoded = yield* Schema.decode(optBuilder.schema)(rawValue).pipe(Effect.mapError((error) => new CommanderError({
                     message: `Invalid value for option ${optBuilder.long}: ${error.message}`,
                     cause: error,
                 })));
@@ -281,9 +278,7 @@ export const runMain = (cmd) => Effect.gen(function* () {
         console.log(generateHelp(cmd));
         return;
     }
-    if (Predicate.hasProperty(parsedOptions, "version")
-        && parsedOptions.version
-        && cmd.version) {
+    if (Predicate.hasProperty(parsedOptions, "version") && parsedOptions.version && cmd.version) {
         console.log(`${cmd.name} v${cmd.version}`);
         return;
     }
@@ -324,10 +319,8 @@ const generateHelp = (cmd) => {
 export const help = (cmd) => generateHelp(cmd);
 export const NumberFromString = Schema.NumberFromString;
 export const choice = (choices) => Schema.Literal(...choices);
-export const repeatable = (schema) => Schema
-    .transform(Schema.String, Schema.Array(Schema.String), {
+export const repeatable = (schema) => Schema.transform(Schema.String, Schema.Array(Schema.String), {
     strict: true,
     decode: (s) => s.split(",").map((part) => part.trim()),
     encode: (arr) => arr.join(","),
-})
-    .pipe(Schema.compose(Schema.Array(schema)));
+}).pipe(Schema.compose(Schema.Array(schema)));

package/dist/ContentNegotiation.d.ts

@@ -2,12 +2,11 @@
  * RFC 7231 Content Negotiation compatible with Express/Node.js ecosystem.
  * Based on {@link https://github.com/jshttp/negotiator}
  */
-import type * as Headers from "@effect/platform/Headers";
-export declare function media(accept: string, available?: string[]): string[];
-export declare function language(accept: string, available?: string[]): string[];
-export declare function encoding(accept: string, available?: string[]): string[];
-export declare function charset(accept: string, available?: string[]): string[];
-export declare function headerMedia(headers: Headers.Headers, available?: string[]): string[];
-export declare function headerLanguage(headers: Headers.Headers, available?: string[]): string[];
-export declare function headerEncoding(headers: Headers.Headers, available?: string[]): string[];
-export declare function headerCharset(headers: Headers.Headers, available?: string[]): string[];
+export declare function media(accept: string, available?: Array<string>): Array<string>;
+export declare function language(accept: string, available?: Array<string>): Array<string>;
+export declare function encoding(accept: string, available?: Array<string>): Array<string>;
+export declare function charset(accept: string, available?: Array<string>): Array<string>;
+export declare function headerMedia(headers: Headers, available?: Array<string>): Array<string>;
+export declare function headerLanguage(headers: Headers, available?: Array<string>): Array<string>;
+export declare function headerEncoding(headers: Headers, available?: Array<string>): Array<string>;
+export declare function headerCharset(headers: Headers, available?: Array<string>): Array<string>;

package/dist/ContentNegotiation.js

@@ -2,7 +2,7 @@
  * RFC 7231 Content Negotiation compatible with Express/Node.js ecosystem.
  * Based on {@link https://github.com/jshttp/negotiator}
  */
-const simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
+const simpleMediaTypeRegExp = /^\s*([^\s/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
 const simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
 const simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
 const simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
@@ -26,7 +26,7 @@ function splitMediaTypeParams(params) {
             continue;
         const key = trimmed.slice(0, eqIndex).trim().toLowerCase();
         let value = trimmed.slice(eqIndex + 1).trim();
-        if (value.startsWith("\"") && value.endsWith("\"")) {
+        if (value.startsWith('"') && value.endsWith('"')) {
             value = value.slice(1, -1);
         }
         if (key === "q") {
@@ -53,9 +53,7 @@ function parseAccept(accept) {
             continue;
         const type = match[1].toLowerCase();
         const subtype = match[2].toLowerCase();
-        const { params, q } = match[3]
-            ? splitMediaTypeParams(match[3])
-            : { params: {}, q: 1 };
+        const { params, q } = match[3] ? splitMediaTypeParams(match[3]) : { params: {}, q: 1 };
         if (q > 0) {
             specs.push({ type, subtype, params, q, o });
         }
@@ -104,16 +102,14 @@ function getMediaTypePriority(mediaType, accepted, index) {
     }
     const type = match[1].toLowerCase();
     const subtype = match[2].toLowerCase();
-    const { params } = match[3]
-        ? splitMediaTypeParams(match[3])
-        : { params: {} };
+    const { params } = match[3] ? splitMediaTypeParams(match[3]) : { params: {} };
     for (const spec of accepted) {
         const result = specifyMediaType(type, subtype, params, spec);
-        if (result
-            && (best === null
-                || result.s > best.s
-                || (result.s === best.s && result.q > best.q)
-                || (result.s === best.s && result.q === best.q && result.o < best.o))) {
+        if (result &&
+            (best === null ||
+                result.s > best.s ||
+                (result.s === best.s && result.q > best.q) ||
+                (result.s === best.s && result.q === best.q && result.o < best.o))) {
             best = result;
         }
     }
@@ -168,11 +164,11 @@ function getLanguagePriority(language, accepted, index) {
     let best = null;
     for (const spec of accepted) {
         const result = specifyLanguage(language, spec);
-        if (result
-            && (best === null
-                || result.s > best.s
-                || (result.s === best.s && result.q > best.q)
-                || (result.s === best.s && result.q === best.q && result.o < best.o))) {
+        if (result &&
+            (best === null ||
+                result.s > best.s ||
+                (result.s === best.s && result.q > best.q) ||
+                (result.s === best.s && result.q === best.q && result.o < best.o))) {
             best = result;
         }
     }
@@ -222,11 +218,11 @@ function getEncodingPriority(encoding, accepted, index) {
     let best = null;
     for (const spec of accepted) {
         const result = specifyEncoding(encoding, spec);
-        if (result
-            && (best === null
-                || result.s > best.s
-                || (result.s === best.s && result.q > best.q)
-                || (result.s === best.s && result.q === best.q && result.o < best.o))) {
+        if (result &&
+            (best === null ||
+                result.s > best.s ||
+                (result.s === best.s && result.q > best.q) ||
+                (result.s === best.s && result.q === best.q && result.o < best.o))) {
             best = result;
         }
     }
@@ -268,11 +264,11 @@ function getCharsetPriority(charset, accepted, index) {
     let best = null;
     for (const spec of accepted) {
         const result = specifyCharset(charset, spec);
-        if (result
-            && (best === null
-                || result.s > best.s
-                || (result.s === best.s && result.q > best.q)
-                || (result.s === best.s && result.q === best.q && result.o < best.o))) {
+        if (result &&
+            (best === null ||
+                result.s > best.s ||
+                (result.s === best.s && result.q > best.q) ||
+                (result.s === best.s && result.q === best.q && result.o < best.o))) {
             best = result;
         }
     }
@@ -285,10 +281,7 @@ function getCharsetPriority(charset, accepted, index) {
     };
 }
 function compareSpecs(a, b) {
-    return (b.q - a.q
-        || b.s - a.s
-        || a.o - b.o
-        || a.i - b.i);
+    return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i;
 }
 export function media(accept, available) {
     const parsed = parseAccept(accept);
@@ -308,7 +301,9 @@ export function language(accept, available) {
         return [];
     }
     if (!available) {
-        return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) => p.suffix ? `${p.prefix}-${p.suffix}` : p.prefix);
+        return parsed
+            .sort((a, b) => b.q - a.q || a.o - b.o)
+            .map((p) => (p.suffix ? `${p.prefix}-${p.suffix}` : p.prefix));
     }
     const priorities = available.map((l, i) => getLanguagePriority(l, parsed, i));
     const sorted = priorities.filter((p) => p.q > 0).sort(compareSpecs);
@@ -339,25 +334,25 @@ export function charset(accept, available) {
     return sorted.map((p) => p.value);
 }
 export function headerMedia(headers, available) {
-    const accept = headers["accept"];
+    const accept = headers.get("accept");
     if (!accept)
         return [];
     return media(accept, available);
 }
 export function headerLanguage(headers, available) {
-    const accept = headers["accept-language"];
+    const accept = headers.get("accept-language");
     if (!accept)
         return [];
     return language(accept, available);
 }
 export function headerEncoding(headers, available) {
-    const accept = headers["accept-encoding"];
+    const accept = headers.get("accept-encoding");
     if (!accept)
         return [];
     return encoding(accept, available);
 }
 export function headerCharset(headers, available) {
-    const accept = headers["accept-charset"];
+    const accept = headers.get("accept-charset");
     if (!accept)
         return [];
     return charset(accept, available);

package/dist/Cookies.d.ts

@@ -0,0 +1,47 @@
+import * as Duration from "effect/Duration";
+import * as Inspectable from "effect/Inspectable";
+import * as Option from "effect/Option";
+import * as Pipeable from "effect/Pipeable";
+export declare const TypeId: unique symbol;
+export type TypeId = typeof TypeId;
+export declare const isCookies: (u: unknown) => u is Cookies;
+export interface Cookies extends Pipeable.Pipeable, Inspectable.Inspectable {
+    readonly [TypeId]: TypeId;
+    readonly cookies: Record<string, Cookie>;
+}
+export declare const CookieTypeId: unique symbol;
+export type CookieTypeId = typeof CookieTypeId;
+export interface Cookie extends Inspectable.Inspectable {
+    readonly [CookieTypeId]: CookieTypeId;
+    readonly name: string;
+    readonly value: string;
+    readonly valueEncoded: string;
+    readonly options?: {
+        readonly domain?: string | undefined;
+        readonly expires?: Date | undefined;
+        readonly maxAge?: Duration.DurationInput | undefined;
+        readonly path?: string | undefined;
+        readonly priority?: "low" | "medium" | "high" | undefined;
+        readonly httpOnly?: boolean | undefined;
+        readonly secure?: boolean | undefined;
+        readonly partitioned?: boolean | undefined;
+        readonly sameSite?: "lax" | "strict" | "none" | undefined;
+    } | undefined;
+}
+export declare const empty: Cookies;
+export declare const fromIterable: (cookies: Iterable<Cookie>) => Cookies;
+export declare const fromSetCookie: (headers: Iterable<string> | string) => Cookies;
+export declare const unsafeMakeCookie: (name: string, value: string, options?: Cookie["options"] | undefined) => Cookie;
+export declare const isEmpty: (self: Cookies) => boolean;
+export declare const get: (self: Cookies, name: string) => Option.Option<Cookie>;
+export declare const getValue: (self: Cookies, name: string) => Option.Option<string>;
+export declare const setCookie: (self: Cookies, cookie: Cookie) => Cookies;
+export declare const unsafeSet: (self: Cookies, name: string, value: string, options?: Cookie["options"]) => Cookies;
+export declare const unsafeSetAll: (self: Cookies, cookies: Iterable<readonly [name: string, value: string, options?: Cookie["options"]]>) => Cookies;
+export declare const remove: (self: Cookies, name: string) => Cookies;
+export declare const merge: (self: Cookies, that: Cookies) => Cookies;
+export declare function serializeCookie(self: Cookie): string;
+export declare const toCookieHeader: (self: Cookies) => string;
+export declare const toRecord: (self: Cookies) => Record<string, string>;
+export declare const toSetCookieHeaders: (self: Cookies) => Array<string>;
+export declare function parseHeader(header: string): Record<string, string>;