the-moby-effect 1.51.7 → 1.54.2

package/src/internal/engines/dockerCompose.ts

@@ -1,12 +1,8 @@
-import type * as ParseResult from "effect/ParseResult";
 import type * as Scope from "effect/Scope";
-import type * as DockerComposeEngine from "../../DockerComposeEngine.js";
-import type * as IdSchemas from "../schemas/id.js";
 
-import * as PlatformError from "@effect/platform/Error";
-import * as Socket from "@effect/platform/Socket";
 import * as Array from "effect/Array";
 import * as Context from "effect/Context";
+import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
@@ -19,6 +15,11 @@ import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import * as String from "effect/String";
 import * as Tuple from "effect/Tuple";
+import * as Socket from "effect/unstable/socket/Socket";
+
+import type * as DockerComposeEngine from "../../DockerComposeEngine.js";
+import type * as IdSchemas from "../schemas/id.js";
+
 import * as DockerEngine from "../../DockerEngine.js";
 import * as MobyDemux from "../../MobyDemux.js";
 import * as MobyEndpoints from "../../MobyEndpoints.js";
@@ -48,9 +49,9 @@ const makeTempDirScoped = (
                 });
             }
 
-            class schema extends Schema.startsWith<typeof Schema.String>("/tmp/")(Schema.String) {}
+            const schema = Schema.String.pipe(Schema.check(Schema.isStartsWith("/tmp/")));
             const tempDir = yield* Effect.mapError(
-                Schema.decode(schema)(stdout),
+                Schema.decodeEffect(schema)(stdout),
                 (cause) =>
                     new DockerComposeError({
                         cause,
@@ -62,16 +63,18 @@ const makeTempDirScoped = (
             return tempDir;
         }),
         (tempDir) =>
-            Effect.orDieWith(
-                DockerEngine.execWebsockets({
-                    containerId,
-                    command: `rm -rf ${tempDir}`,
-                }),
-                (cause) =>
-                    new DockerComposeError({
-                        cause,
-                        method: "makeTempDirScoped",
-                    })
+            Effect.orDie(
+                Effect.mapError(
+                    DockerEngine.execWebsockets({
+                        containerId,
+                        command: `rm -rf ${tempDir}`,
+                    }),
+                    (cause) =>
+                        new DockerComposeError({
+                            cause,
+                            method: "makeTempDirScoped",
+                        })
+                )
             )
     );
 
@@ -128,13 +131,13 @@ const stringifyOptions = (
     Function.pipe(
         options,
         Record.toEntries,
-        Array.filter(Function.flow(Tuple.getSecond, Predicate.isNotUndefined)),
+        Array.filter(([, value]) => Predicate.isNotUndefined(value)),
         Array.flatMap(([key, value]): Array<readonly [string, string | number | boolean]> => {
             if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) {
                 return [Tuple.make(key, value)];
             } else if (Array.isArray(value)) {
                 return Array.map(value, (v) => [key, v]);
-            } else if (Predicate.isRecord(value)) {
+            } else if (Predicate.isObject(value)) {
                 return Record.toEntries(value);
             } else {
                 return Function.absurd(value as never);
@@ -220,18 +223,20 @@ export const isDockerComposeError = (u: unknown): u is DockerComposeError =>
     Predicate.hasProperty(u, DockerComposeErrorTypeId);
 
 /** @internal */
-export class DockerComposeError extends PlatformError.TypeIdError(DockerComposeErrorTypeId, "DockerComposeError")<{
+export class DockerComposeError extends Data.TaggedError("DockerComposeError")<{
     method: string;
-    cause: ParseResult.ParseError | Socket.SocketError | DockerEngine.DockerError | unknown;
+    cause: Schema.SchemaError | Socket.SocketError | DockerEngine.DockerError | unknown;
 }> {
+    public readonly [DockerComposeErrorTypeId]: DockerComposeEngine.DockerComposeErrorTypeId = DockerComposeErrorTypeId;
+
     public override get message() {
         return `${String.capitalize(this.method)}`;
     }
 }
 
 /** @internal */
-export const DockerCompose: Context.Tag<DockerComposeEngine.DockerCompose, DockerComposeEngine.DockerCompose> =
-    Context.GenericTag<DockerComposeEngine.DockerCompose>("@the-moby-effect/engines/DockerCompose");
+export const DockerCompose: Context.Service<DockerComposeEngine.DockerCompose, DockerComposeEngine.DockerCompose> =
+    Context.Service<DockerComposeEngine.DockerCompose>("@the-moby-effect/engines/DockerCompose");
 
 /** @internal */
 export const make: (options?: {
@@ -267,7 +272,7 @@ export const make: (options?: {
                 runCommandHelper(dindContainerId, projectPath, "config", services, { ...options }),
                 Stream.decodeText(),
                 Stream.splitLines,
-                Stream.run(Sink.mkString)
+                Stream.mkString
             );
 
     const cpTo =
@@ -302,7 +307,9 @@ export const make: (options?: {
             options?: DockerComposeEngine.CopyOptions | undefined
         ): Stream.Stream<Uint8Array, DockerComposeError, never> =>
             Function.pipe(
-                Stream.scoped(makeTempDirScoped(dindContainerId)),
+                makeTempDirScoped(dindContainerId),
+                Stream.fromEffect,
+                Stream.scoped,
                 Stream.provideService(MobyEndpoints.Containers, containers),
                 Stream.tap((remoteTransferDir) =>
                     Stream.runDrain(
@@ -579,7 +586,7 @@ export const make: (options?: {
             Function.pipe(
                 runCommandHelper(dindContainerId, projectPath, "version", [], { ...options }),
                 Stream.decodeText(),
-                Stream.run(Sink.mkString)
+                Stream.mkString
             );
 
     const wait =
@@ -622,10 +629,11 @@ export const make: (options?: {
             project: Stream.Stream<Uint8Array, E1, R1>,
             ...args: P
         ): Effect.Effect<A, E | E1 | DockerComposeError, Exclude<R, Scope.Scope> | Exclude<R1, Scope.Scope>> =>
-            uploadProject(project)(dindContainerId)
-                .pipe(Effect.provideService(MobyEndpoints.Containers, containers))
-                .pipe(Effect.flatMap((cwd) => func(dindContainerId, cwd)(...args)))
-                .pipe(Effect.scoped);
+            uploadProject(project)(dindContainerId).pipe(
+                Effect.provideService(MobyEndpoints.Containers, containers),
+                Effect.flatMap((cwd) => func(dindContainerId, cwd)(...args)),
+                Effect.scoped
+            );
 
     const uncurryStreamWithUploadProject =
         (dindContainerId: IdSchemas.ContainerIdentifier) =>
@@ -639,10 +647,12 @@ export const make: (options?: {
             project: Stream.Stream<Uint8Array, E1, R1>,
             ...args: P
         ): Stream.Stream<A, E | E1 | DockerComposeError, R | R1> =>
-            uploadProject(project)(dindContainerId)
-                .pipe(Stream.scoped)
-                .pipe(Stream.provideService(MobyEndpoints.Containers, containers))
-                .pipe(Stream.flatMap((cwd) => func(dindContainerId, cwd)(...args)));
+            uploadProject(project)(dindContainerId).pipe(
+                Stream.fromEffect,
+                Stream.scoped,
+                Stream.provideService(MobyEndpoints.Containers, containers),
+                Stream.flatMap((cwd) => func(dindContainerId, cwd)(...args))
+            );
 
     const uncurryEffect = uncurryEffectWithUploadProject(dindContainerIdResource);
     const uncurryStream = uncurryStreamWithUploadProject(dindContainerIdResource);
@@ -711,9 +721,10 @@ export const make: (options?: {
                         Privileged: true,
                         Binds: [`${options?.dockerEngineSocket ?? "/var/run/docker.sock"}:/var/run/docker.sock`],
                     },
-                })
-                    .pipe(Effect.map(({ Id }) => Id))
-                    .pipe(Effect.provideService(MobyEndpoints.Containers, containers));
+                }).pipe(
+                    Effect.map(({ Id }) => Id),
+                    Effect.provideService(MobyEndpoints.Containers, containers)
+                );
 
                 const cwd = yield* Effect.provideService(
                     uploadProject(projectDindContainerIdResource, project),
@@ -762,22 +773,22 @@ export const layer = (
     DockerComposeEngine.DockerCompose,
     DockerEngine.DockerError,
     MobyEndpoints.Containers | MobyEndpoints.System | MobyEndpoints.Images
-> => Layer.scoped(DockerCompose, make(options));
+> => Layer.effect(DockerCompose, make(options));
 
 /** @internal */
 export const layerProject: <E1>(
     project: Stream.Stream<Uint8Array, E1, never>,
     tagIdentifier: string
 ) => {
-    readonly tag: Context.Tag<DockerComposeEngine.DockerComposeProject, DockerComposeEngine.DockerComposeProject>;
+    readonly tag: Context.Service<DockerComposeEngine.DockerComposeProject, DockerComposeEngine.DockerComposeProject>;
     readonly layer: Layer.Layer<
         DockerComposeEngine.DockerComposeProject,
         E1 | DockerComposeError | DockerEngine.DockerError,
         DockerComposeEngine.DockerCompose
     >;
 } = <E1>(project: Stream.Stream<Uint8Array, E1, never>, tagIdentifier: string) => {
-    const tag = Context.GenericTag<DockerComposeEngine.DockerComposeProject>(tagIdentifier);
+    const tag = Context.Service<DockerComposeEngine.DockerComposeProject>(tagIdentifier);
     const effect = Effect.flatMap(DockerCompose, ({ forProject }) => forProject(project));
-    const layer = Layer.scoped(tag, effect);
+    const layer = Layer.effect(tag, effect);
     return { tag, layer } as const;
 };

package/src/internal/generated/ArchiveChange.generated.ts

@@ -1,10 +1,13 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ArchiveChange extends Schema.Class<ArchiveChange>("ArchiveChange")(
     {
         Path: Schema.String,
-        Kind: EffectSchemas.Number.I64,
+        Kind: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
     },
     {
         identifier: "ArchiveChange",

package/src/internal/generated/BlkiodevThrottleDevice.generated.ts

@@ -1,10 +1,11 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class BlkiodevThrottleDevice extends Schema.Class<BlkiodevThrottleDevice>("BlkiodevThrottleDevice")(
     {
         Path: Schema.String,
-        Rate: EffectSchemas.Number.U64,
+        Rate: MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })),
     },
     {
         identifier: "BlkiodevThrottleDevice",

package/src/internal/generated/BlkiodevWeightDevice.generated.ts

@@ -1,10 +1,14 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class BlkiodevWeightDevice extends Schema.Class<BlkiodevWeightDevice>("BlkiodevWeightDevice")(
     {
         Path: Schema.String,
-        Weight: EffectSchemas.Number.U16,
+        Weight: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 16 - 1 })
+        ),
     },
     {
         identifier: "BlkiodevWeightDevice",

package/src/internal/generated/BuildCacheRecord.generated.ts

@@ -1,19 +1,24 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class BuildCacheRecord extends Schema.Class<BuildCacheRecord>("BuildCacheRecord")(
     {
         ID: Schema.String,
         Parent: Schema.optional(Schema.String),
-        " Parents": Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        " Parents": Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
         Type: Schema.String,
         Description: Schema.String,
         InUse: Schema.Boolean,
         Shared: Schema.Boolean,
-        Size: EffectSchemas.Number.I64,
+        Size: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         CreatedAt: Schema.NullOr(Schema.DateFromString),
         LastUsedAt: Schema.NullOr(Schema.DateFromString),
-        UsageCount: EffectSchemas.Number.I64,
+        UsageCount: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
     },
     {
         identifier: "BuildCacheRecord",

package/src/internal/generated/ContainerBlkioStatEntry.generated.ts

@@ -1,12 +1,13 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerBlkioStatEntry extends Schema.Class<ContainerBlkioStatEntry>("ContainerBlkioStatEntry")(
     {
-        major: EffectSchemas.Number.U64,
-        minor: EffectSchemas.Number.U64,
+        major: MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })),
+        minor: MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })),
         op: Schema.String,
-        value: EffectSchemas.Number.U64,
+        value: MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })),
     },
     {
         identifier: "ContainerBlkioStatEntry",

package/src/internal/generated/ContainerBlkioStats.generated.ts

@@ -1,5 +1,6 @@
 import * as Schema from "effect/Schema";
-import * as ContainerBlkioStatEntry from "./ContainerBlkioStatEntry.generated.js";
+
+import * as ContainerBlkioStatEntry from "./ContainerBlkioStatEntry.generated.ts";
 
 export class ContainerBlkioStats extends Schema.Class<ContainerBlkioStats>("ContainerBlkioStats")(
     {

package/src/internal/generated/ContainerCPUStats.generated.ts

@@ -1,14 +1,22 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as ContainerCPUUsage from "./ContainerCPUUsage.generated.js";
-import * as ContainerThrottlingData from "./ContainerThrottlingData.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as ContainerCPUUsage from "./ContainerCPUUsage.generated.ts";
+import * as ContainerThrottlingData from "./ContainerThrottlingData.generated.ts";
 
 export class ContainerCPUStats extends Schema.Class<ContainerCPUStats>("ContainerCPUStats")(
     {
         cpu_usage: Schema.NullOr(ContainerCPUUsage.ContainerCPUUsage),
-        system_cpu_usage: Schema.optional(EffectSchemas.Number.U64),
-        online_cpus: Schema.optional(EffectSchemas.Number.U32),
-        throttling_data: Schema.optionalWith(ContainerThrottlingData.ContainerThrottlingData, { nullable: true }),
+        system_cpu_usage: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        online_cpus: Schema.optional(
+            MobyNumber.NumberFromWireString.check(
+                Schema.isInt(),
+                Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+            )
+        ),
+        throttling_data: Schema.optional(Schema.NullOr(ContainerThrottlingData.ContainerThrottlingData)),
     },
     {
         identifier: "ContainerCPUStats",

package/src/internal/generated/ContainerCPUUsage.generated.ts

@@ -1,12 +1,27 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerCPUUsage extends Schema.Class<ContainerCPUUsage>("ContainerCPUUsage")(
     {
-        total_usage: EffectSchemas.Number.U64,
-        percpu_usage: Schema.optionalWith(Schema.Array(EffectSchemas.Number.U64), { nullable: true }),
-        usage_in_kernelmode: EffectSchemas.Number.U64,
-        usage_in_usermode: EffectSchemas.Number.U64,
+        total_usage: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        percpu_usage: Schema.optional(
+            Schema.NullOr(
+                Schema.Array(
+                    MobyNumber.BigIntFromWireString.check(
+                        Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+                    )
+                )
+            )
+        ),
+        usage_in_kernelmode: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        usage_in_usermode: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
     },
     {
         identifier: "ContainerCPUUsage",

package/src/internal/generated/ContainerConfig.generated.ts

@@ -1,47 +1,51 @@
-import * as EffectSchemas from "effect-schemas";
+import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+
+import * as MobyNumber from "../schemas/number.ts";
 import * as PortSchemas from "../schemas/port.ts";
-import * as V1HealthcheckConfig from "./V1HealthcheckConfig.generated.js";
+import * as V1HealthcheckConfig from "./V1HealthcheckConfig.generated.ts";
 
 export class ContainerConfig extends Schema.Class<ContainerConfig>("ContainerConfig")(
     {
-        Hostname: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        Domainname: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        User: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        AttachStdin: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        AttachStdout: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        AttachStderr: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        ExposedPorts: Schema.optionalWith(PortSchemas.PortSet, { nullable: true }),
-        Tty: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        OpenStdin: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        StdinOnce: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        Env: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        Cmd: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        Healthcheck: Schema.optionalWith(V1HealthcheckConfig.V1HealthcheckConfig, { nullable: true }),
+        Hostname: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Domainname: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        User: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        AttachStdin: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        AttachStdout: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        AttachStderr: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        ExposedPorts: Schema.optional(Schema.NullOr(PortSchemas.PortSet)),
+        Tty: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        OpenStdin: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        StdinOnce: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        Env: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        Cmd: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        Healthcheck: Schema.optional(Schema.NullOr(V1HealthcheckConfig.V1HealthcheckConfig)),
         ArgsEscaped: Schema.optional(Schema.Boolean),
         Image: Schema.String,
-        Volumes: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.Object }))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        WorkingDir: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        Entrypoint: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
+        Volumes: Schema.NullOr(Schema.Record(Schema.String, Schema.ObjectKeyword)).pipe(
+            Schema.withConstructorDefault(Effect.succeed(null))
+        ),
+        WorkingDir: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Entrypoint: Schema.NullOr(Schema.Array(Schema.String)).pipe(
+            Schema.withConstructorDefault(Effect.succeed(null))
+        ),
         NetworkDisabled: Schema.optional(Schema.Boolean),
         MacAddress: Schema.optional(Schema.String),
-        OnBuild: Schema.NullishOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        Labels: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String }))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
+        OnBuild: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))).pipe(
+            Schema.withConstructorDefault(Effect.succeed(null))
+        ),
+        Labels: Schema.NullOr(Schema.Record(Schema.String, Schema.String)).pipe(
+            Schema.withConstructorDefault(Effect.succeed(null))
+        ),
         StopSignal: Schema.optional(Schema.String),
-        StopTimeout: Schema.optionalWith(EffectSchemas.Number.I64, { nullable: true }),
-        Shell: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        StopTimeout: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(
+                    Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+                )
+            )
+        ),
+        Shell: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
     },
     {
         identifier: "ContainerConfig",

package/src/internal/generated/ContainerContainerJSONBase.generated.ts

@@ -1,14 +1,15 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
+
 import * as MobyIdentifiers from "../schemas/id.ts";
-import * as ContainerHostConfig from "./ContainerHostConfig.generated.js";
-import * as ContainerState from "./ContainerState.generated.js";
-import * as StorageDriverData from "./StorageDriverData.generated.js";
+import * as MobyNumber from "../schemas/number.ts";
+import * as ContainerHostConfig from "./ContainerHostConfig.generated.ts";
+import * as ContainerState from "./ContainerState.generated.ts";
+import * as StorageDriverData from "./StorageDriverData.generated.ts";
 
 export class ContainerContainerJSONBase extends Schema.Class<ContainerContainerJSONBase>("ContainerContainerJSONBase")(
     {
         Id: MobyIdentifiers.ContainerIdentifier,
-        Created: Schema.String,
+        Created: Schema.DateFromString,
         Path: Schema.String,
         Args: Schema.NullOr(Schema.Array(Schema.String)),
         State: Schema.NullOr(ContainerState.ContainerState),
@@ -18,7 +19,9 @@ export class ContainerContainerJSONBase extends Schema.Class<ContainerContainerJ
         HostsPath: Schema.String,
         LogPath: Schema.String,
         Name: Schema.String,
-        RestartCount: EffectSchemas.Number.I64,
+        RestartCount: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         Driver: Schema.String,
         Platform: Schema.String,
         MountLabel: Schema.String,
@@ -26,9 +29,21 @@ export class ContainerContainerJSONBase extends Schema.Class<ContainerContainerJ
         AppArmorProfile: Schema.String,
         ExecIDs: Schema.NullOr(Schema.Array(Schema.String)),
         HostConfig: Schema.NullOr(ContainerHostConfig.ContainerHostConfig),
-        GraphDriver: Schema.NullishOr(StorageDriverData.StorageDriverData), // optional for docker.io/library/docker:26-dind-rootless
-        SizeRw: Schema.optionalWith(EffectSchemas.Number.I64, { nullable: true }),
-        SizeRootFs: Schema.optionalWith(EffectSchemas.Number.I64, { nullable: true }),
+        GraphDriver: Schema.optional(Schema.NullOr(StorageDriverData.StorageDriverData)),
+        SizeRw: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(
+                    Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+                )
+            )
+        ),
+        SizeRootFs: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(
+                    Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+                )
+            )
+        ),
     },
     {
         identifier: "ContainerContainerJSONBase",

package/src/internal/generated/ContainerCreateRequest.generated.ts

@@ -1,13 +1,14 @@
 import * as Schema from "effect/Schema";
-import * as ContainerConfig from "./ContainerConfig.generated.js";
-import * as ContainerHostConfig from "./ContainerHostConfig.generated.js";
-import * as NetworkNetworkingConfig from "./NetworkNetworkingConfig.generated.js";
+
+import * as ContainerConfig from "./ContainerConfig.generated.ts";
+import * as ContainerHostConfig from "./ContainerHostConfig.generated.ts";
+import * as NetworkNetworkingConfig from "./NetworkNetworkingConfig.generated.ts";
 
 export class ContainerCreateRequest extends Schema.Class<ContainerCreateRequest>("ContainerCreateRequest")(
     {
         ...ContainerConfig.ContainerConfig.fields,
-        HostConfig: Schema.optionalWith(ContainerHostConfig.ContainerHostConfig, { nullable: true }),
-        NetworkingConfig: Schema.optionalWith(NetworkNetworkingConfig.NetworkNetworkingConfig, { nullable: true }),
+        HostConfig: Schema.optional(Schema.NullOr(ContainerHostConfig.ContainerHostConfig)),
+        NetworkingConfig: Schema.optional(Schema.NullOr(NetworkNetworkingConfig.NetworkNetworkingConfig)),
     },
     {
         identifier: "ContainerCreateRequest",

package/src/internal/generated/ContainerDefaultNetworkSettings.generated.ts

@@ -1,18 +1,27 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerDefaultNetworkSettings extends Schema.Class<ContainerDefaultNetworkSettings>(
     "ContainerDefaultNetworkSettings"
 )(
     {
-        EndpointID: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
-        Gateway: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
-        GlobalIPv6Address: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
-        GlobalIPv6PrefixLen: Schema.optional(EffectSchemas.Number.I64), // optional for docker.io/library/docker:26-dind-rootless
-        IPAddress: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
-        IPPrefixLen: Schema.optional(EffectSchemas.Number.I64), // optional for docker.io/library/docker:26-dind-rootless
-        IPv6Gateway: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
-        MacAddress: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        EndpointID: Schema.optional(Schema.String),
+        Gateway: Schema.optional(Schema.String),
+        GlobalIPv6Address: Schema.optional(Schema.String),
+        GlobalIPv6PrefixLen: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        IPAddress: Schema.optional(Schema.String),
+        IPPrefixLen: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        IPv6Gateway: Schema.optional(Schema.String),
+        MacAddress: Schema.optional(Schema.String),
     },
     {
         identifier: "ContainerDefaultNetworkSettings",

package/src/internal/generated/ContainerDeviceRequest.generated.ts

@@ -1,13 +1,16 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerDeviceRequest extends Schema.Class<ContainerDeviceRequest>("ContainerDeviceRequest")(
     {
         Driver: Schema.String,
-        Count: EffectSchemas.Number.I64,
+        Count: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         DeviceIDs: Schema.NullOr(Schema.Array(Schema.String)),
         Capabilities: Schema.NullOr(Schema.Array(Schema.NullOr(Schema.Array(Schema.String)))),
-        Options: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
+        Options: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
     },
     {
         identifier: "ContainerDeviceRequest",

package/src/internal/generated/ContainerExecInspect.generated.ts

@@ -1,13 +1,19 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerExecInspect extends Schema.Class<ContainerExecInspect>("ContainerExecInspect")(
     {
-        ID: Schema.String,
-        ContainerID: Schema.String,
+        ID: MobyIdentifiers.ExecIdentifier,
+        ContainerID: MobyIdentifiers.ContainerIdentifier,
         Running: Schema.Boolean,
-        ExitCode: EffectSchemas.Number.I64,
-        Pid: EffectSchemas.Number.I64,
+        ExitCode: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        Pid: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
     },
     {
         identifier: "ContainerExecInspect",