the-moby-effect 1.45.0-alpha.8 → 1.48.0

package/dist/dts/internal/generated/SwarmResourceRequirements.generated.d.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+import * as SwarmLimit from "./SwarmLimit.generated.js";
+import * as SwarmResources from "./SwarmResources.generated.js";
+declare const SwarmResourceRequirements_base: Schema.Class<SwarmResourceRequirements, {
+    Limits: Schema.optionalWith<typeof SwarmLimit.SwarmLimit, {
+        nullable: true;
+    }>;
+    Reservations: Schema.optionalWith<typeof SwarmResources.SwarmResources, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    Limits: Schema.optionalWith<typeof SwarmLimit.SwarmLimit, {
+        nullable: true;
+    }>;
+    Reservations: Schema.optionalWith<typeof SwarmResources.SwarmResources, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly Limits?: SwarmLimit.SwarmLimit | undefined;
+} & {
+    readonly Reservations?: SwarmResources.SwarmResources | undefined;
+}, {}, {}>;
+export declare class SwarmResourceRequirements extends SwarmResourceRequirements_base {
+}
+export {};
+//# sourceMappingURL=SwarmResourceRequirements.generated.d.ts.map

package/dist/dts/internal/generated/SwarmResourceRequirements.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmResourceRequirements.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmResourceRequirements.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,cAAc,MAAM,+BAA+B,CAAC;;;;;;;;;;;;;;;;;;;;AAEhE,qBAAa,yBAA0B,SAAQ,8BAW9C;CAAG"}

package/dist/dts/internal/generated/SwarmResources.generated.d.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+import * as SwarmGenericResource from "./SwarmGenericResource.generated.js";
+declare const SwarmResources_base: Schema.Class<SwarmResources, {
+    NanoCPUs: Schema.optional<MobySchemas.Int64Schemas.$Int64>;
+    MemoryBytes: Schema.optional<MobySchemas.Int64Schemas.$Int64>;
+    GenericResources: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmGenericResource.SwarmGenericResource>>, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    NanoCPUs: Schema.optional<MobySchemas.Int64Schemas.$Int64>;
+    MemoryBytes: Schema.optional<MobySchemas.Int64Schemas.$Int64>;
+    GenericResources: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmGenericResource.SwarmGenericResource>>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly NanoCPUs?: MobySchemas.Int64Schemas.Int64Brand | undefined;
+} & {
+    readonly MemoryBytes?: MobySchemas.Int64Schemas.Int64Brand | undefined;
+} & {
+    readonly GenericResources?: readonly (SwarmGenericResource.SwarmGenericResource | null)[] | undefined;
+}, {}, {}>;
+export declare class SwarmResources extends SwarmResources_base {
+}
+export {};
+//# sourceMappingURL=SwarmResources.generated.d.ts.map

package/dist/dts/internal/generated/SwarmResources.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmResources.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmResources.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,oBAAoB,MAAM,qCAAqC,CAAC;;;;;;;;;;;;;;;;;;;;AAE5E,qBAAa,cAAe,SAAQ,mBAcnC;CAAG"}

package/dist/dts/internal/generated/SwarmRestartPolicy.generated.d.ts

@@ -0,0 +1,37 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+declare const SwarmRestartPolicy_base: Schema.Class<SwarmRestartPolicy, {
+    Condition: Schema.optional<typeof Schema.String>;
+    Delay: Schema.optionalWith<MobySchemas.Int64Schemas.$Int64, {
+        nullable: true;
+    }>;
+    MaxAttempts: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+    Window: Schema.optionalWith<MobySchemas.Int64Schemas.$Int64, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    Condition: Schema.optional<typeof Schema.String>;
+    Delay: Schema.optionalWith<MobySchemas.Int64Schemas.$Int64, {
+        nullable: true;
+    }>;
+    MaxAttempts: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+    Window: Schema.optionalWith<MobySchemas.Int64Schemas.$Int64, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly Condition?: string | undefined;
+} & {
+    readonly Delay?: MobySchemas.Int64Schemas.Int64Brand | undefined;
+} & {
+    readonly MaxAttempts?: MobySchemas.UInt64Schemas.UInt64Brand | undefined;
+} & {
+    readonly Window?: MobySchemas.Int64Schemas.Int64Brand | undefined;
+}, {}, {}>;
+export declare class SwarmRestartPolicy extends SwarmRestartPolicy_base {
+}
+export {};
+//# sourceMappingURL=SwarmRestartPolicy.generated.d.ts.map

package/dist/dts/internal/generated/SwarmRestartPolicy.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmRestartPolicy.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmRestartPolicy.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnD,qBAAa,kBAAmB,SAAQ,uBAavC;CAAG"}

package/dist/dts/internal/generated/SwarmSELinuxContext.generated.d.ts

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+declare const SwarmSELinuxContext_base: Schema.Class<SwarmSELinuxContext, {
+    Disable: typeof Schema.Boolean;
+    User: typeof Schema.String;
+    Role: typeof Schema.String;
+    Type: typeof Schema.String;
+    Level: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    Disable: typeof Schema.Boolean;
+    User: typeof Schema.String;
+    Role: typeof Schema.String;
+    Type: typeof Schema.String;
+    Level: typeof Schema.String;
+}>, never, {
+    readonly Type: string;
+} & {
+    readonly User: string;
+} & {
+    readonly Disable: boolean;
+} & {
+    readonly Role: string;
+} & {
+    readonly Level: string;
+}, {}, {}>;
+export declare class SwarmSELinuxContext extends SwarmSELinuxContext_base {
+}
+export {};
+//# sourceMappingURL=SwarmSELinuxContext.generated.d.ts.map

package/dist/dts/internal/generated/SwarmSELinuxContext.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSELinuxContext.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmSELinuxContext.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAExC,qBAAa,mBAAoB,SAAQ,wBAcxC;CAAG"}

package/dist/dts/internal/generated/SwarmSeccompOpts.generated.d.ts

@@ -0,0 +1,21 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+declare const SwarmSeccompOpts_base: Schema.Class<SwarmSeccompOpts, {
+    Mode: Schema.optional<typeof Schema.String>;
+    Profile: Schema.optionalWith<Schema.Array$<MobySchemas.UInt8Schemas.$UInt8>, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    Mode: Schema.optional<typeof Schema.String>;
+    Profile: Schema.optionalWith<Schema.Array$<MobySchemas.UInt8Schemas.$UInt8>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly Mode?: string | undefined;
+} & {
+    readonly Profile?: readonly MobySchemas.UInt8Schemas.UInt8Brand[] | undefined;
+}, {}, {}>;
+export declare class SwarmSeccompOpts extends SwarmSeccompOpts_base {
+}
+export {};
+//# sourceMappingURL=SwarmSeccompOpts.generated.d.ts.map

package/dist/dts/internal/generated/SwarmSeccompOpts.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSeccompOpts.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmSeccompOpts.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;;;;;;;;;;;;;;;;AAEnD,qBAAa,gBAAiB,SAAQ,qBAWrC;CAAG"}

package/dist/dts/internal/generated/SwarmSecret.generated.d.ts

@@ -0,0 +1,41 @@
+import * as Schema from "effect/Schema";
+import * as SwarmSecretSpec from "./SwarmSecretSpec.generated.js";
+declare const SwarmSecret_base: Schema.Class<SwarmSecret, {
+    Spec: Schema.NullOr<typeof SwarmSecretSpec.SwarmSecretSpec>;
+    Version: Schema.optionalWith<typeof import("./SwarmVersion.generated.js").SwarmVersion, {
+        nullable: true;
+    }>;
+    CreatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    UpdatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    ID: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    Spec: Schema.NullOr<typeof SwarmSecretSpec.SwarmSecretSpec>;
+    Version: Schema.optionalWith<typeof import("./SwarmVersion.generated.js").SwarmVersion, {
+        nullable: true;
+    }>;
+    CreatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    UpdatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    ID: typeof Schema.String;
+}>, never, {
+    readonly ID: string;
+} & {
+    readonly CreatedAt?: Date | undefined;
+} & {
+    readonly Version?: import("./SwarmVersion.generated.js").SwarmVersion | undefined;
+} & {
+    readonly UpdatedAt?: Date | undefined;
+} & {
+    readonly Spec: SwarmSecretSpec.SwarmSecretSpec | null;
+}, {}, {}>;
+export declare class SwarmSecret extends SwarmSecret_base {
+}
+export {};
+//# sourceMappingURL=SwarmSecret.generated.d.ts.map

package/dist/dts/internal/generated/SwarmSecret.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSecret.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmSecret.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,eAAe,MAAM,gCAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElE,qBAAa,WAAY,SAAQ,gBAYhC;CAAG"}

package/dist/dts/internal/generated/SwarmSecretCreateResponse.generated.d.ts

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+declare const SwarmSecretCreateResponse_base: Schema.Class<SwarmSecretCreateResponse, {
+    ID: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    ID: typeof Schema.String;
+}>, never, {
+    readonly ID: string;
+}, {}, {}>;
+export declare class SwarmSecretCreateResponse extends SwarmSecretCreateResponse_base {
+}
+export {};
+//# sourceMappingURL=SwarmSecretCreateResponse.generated.d.ts.map

package/dist/dts/internal/generated/SwarmSecretCreateResponse.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSecretCreateResponse.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmSecretCreateResponse.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;AAExC,qBAAa,yBAA0B,SAAQ,8BAU9C;CAAG"}

package/dist/dts/internal/generated/SwarmSecretReference.generated.d.ts

@@ -0,0 +1,21 @@
+import * as Schema from "effect/Schema";
+import * as SwarmSecretReferenceFileTarget from "./SwarmSecretReferenceFileTarget.generated.js";
+declare const SwarmSecretReference_base: Schema.Class<SwarmSecretReference, {
+    File: Schema.NullOr<typeof SwarmSecretReferenceFileTarget.SwarmSecretReferenceFileTarget>;
+    SecretID: typeof Schema.String;
+    SecretName: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    File: Schema.NullOr<typeof SwarmSecretReferenceFileTarget.SwarmSecretReferenceFileTarget>;
+    SecretID: typeof Schema.String;
+    SecretName: typeof Schema.String;
+}>, never, {
+    readonly File: SwarmSecretReferenceFileTarget.SwarmSecretReferenceFileTarget | null;
+} & {
+    readonly SecretID: string;
+} & {
+    readonly SecretName: string;
+}, {}, {}>;
+export declare class SwarmSecretReference extends SwarmSecretReference_base {
+}
+export {};
+//# sourceMappingURL=SwarmSecretReference.generated.d.ts.map

package/dist/dts/internal/generated/SwarmSecretReference.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSecretReference.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmSecretReference.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,8BAA8B,MAAM,+CAA+C,CAAC;;;;;;;;;;;;;;;;AAEhG,qBAAa,oBAAqB,SAAQ,yBAYzC;CAAG"}

package/dist/dts/internal/generated/SwarmSecretReferenceFileTarget.generated.d.ts

@@ -0,0 +1,25 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+declare const SwarmSecretReferenceFileTarget_base: Schema.Class<SwarmSecretReferenceFileTarget, {
+    Name: typeof Schema.String;
+    UID: typeof Schema.String;
+    GID: typeof Schema.String;
+    Mode: MobySchemas.UInt32Schemas.$UInt32;
+}, Schema.Struct.Encoded<{
+    Name: typeof Schema.String;
+    UID: typeof Schema.String;
+    GID: typeof Schema.String;
+    Mode: MobySchemas.UInt32Schemas.$UInt32;
+}>, never, {
+    readonly Name: string;
+} & {
+    readonly Mode: MobySchemas.UInt32Schemas.UInt32Brand;
+} & {
+    readonly GID: string;
+} & {
+    readonly UID: string;
+}, {}, {}>;
+export declare class SwarmSecretReferenceFileTarget extends SwarmSecretReferenceFileTarget_base {
+}
+export {};
+//# sourceMappingURL=SwarmSecretReferenceFileTarget.generated.d.ts.map

package/dist/dts/internal/generated/SwarmSecretReferenceFileTarget.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSecretReferenceFileTarget.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmSecretReferenceFileTarget.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;AAEnD,qBAAa,8BAA+B,SAAQ,mCAenD;CAAG"}

package/dist/dts/internal/generated/SwarmSecretSpec.generated.d.ts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+import * as SwarmDriver from "./SwarmDriver.generated.js";
+declare const SwarmSecretSpec_base: Schema.Class<SwarmSecretSpec, {
+    Data: Schema.optionalWith<Schema.Schema<string, string, never>, {
+        nullable: true;
+    }>;
+    Driver: Schema.optionalWith<typeof SwarmDriver.SwarmDriver, {
+        nullable: true;
+    }>;
+    Templating: Schema.optionalWith<typeof SwarmDriver.SwarmDriver, {
+        nullable: true;
+    }>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}, Schema.Struct.Encoded<{
+    Data: Schema.optionalWith<Schema.Schema<string, string, never>, {
+        nullable: true;
+    }>;
+    Driver: Schema.optionalWith<typeof SwarmDriver.SwarmDriver, {
+        nullable: true;
+    }>;
+    Templating: Schema.optionalWith<typeof SwarmDriver.SwarmDriver, {
+        nullable: true;
+    }>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}>, never, {
+    readonly Name?: string | undefined;
+} & {
+    readonly Labels: {
+        readonly [x: string]: string;
+    } | null;
+} & {
+    readonly Driver?: SwarmDriver.SwarmDriver | undefined;
+} & {
+    readonly Data?: string | undefined;
+} & {
+    readonly Templating?: SwarmDriver.SwarmDriver | undefined;
+}, {}, {}>;
+export declare class SwarmSecretSpec extends SwarmSecretSpec_base {
+}
+export {};
+//# sourceMappingURL=SwarmSecretSpec.generated.d.ts.map

package/dist/dts/internal/generated/SwarmSecretSpec.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSecretSpec.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmSecretSpec.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,WAAW,MAAM,4BAA4B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1D,qBAAa,eAAgB,SAAQ,oBAapC;CAAG"}

package/dist/dts/internal/generated/SwarmService.generated.d.ts

@@ -0,0 +1,89 @@
+import * as Schema from "effect/Schema";
+import * as SwarmEndpoint from "./SwarmEndpoint.generated.js";
+import * as SwarmJobStatus from "./SwarmJobStatus.generated.js";
+import * as SwarmServiceSpec from "./SwarmServiceSpec.generated.js";
+import * as SwarmServiceStatus from "./SwarmServiceStatus.generated.js";
+import * as SwarmUpdateStatus from "./SwarmUpdateStatus.generated.js";
+declare const SwarmService_base: Schema.Class<SwarmService, {
+    Spec: Schema.optionalWith<typeof SwarmServiceSpec.SwarmServiceSpec, {
+        nullable: true;
+    }>;
+    PreviousSpec: Schema.optionalWith<typeof SwarmServiceSpec.SwarmServiceSpec, {
+        nullable: true;
+    }>;
+    Endpoint: Schema.optionalWith<typeof SwarmEndpoint.SwarmEndpoint, {
+        nullable: true;
+    }>;
+    UpdateStatus: Schema.optionalWith<typeof SwarmUpdateStatus.SwarmUpdateStatus, {
+        nullable: true;
+    }>;
+    ServiceStatus: Schema.optionalWith<typeof SwarmServiceStatus.SwarmServiceStatus, {
+        nullable: true;
+    }>;
+    JobStatus: Schema.optionalWith<typeof SwarmJobStatus.SwarmJobStatus, {
+        nullable: true;
+    }>;
+    Version: Schema.optionalWith<typeof import("./SwarmVersion.generated.js").SwarmVersion, {
+        nullable: true;
+    }>;
+    CreatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    UpdatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    ID: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    Spec: Schema.optionalWith<typeof SwarmServiceSpec.SwarmServiceSpec, {
+        nullable: true;
+    }>;
+    PreviousSpec: Schema.optionalWith<typeof SwarmServiceSpec.SwarmServiceSpec, {
+        nullable: true;
+    }>;
+    Endpoint: Schema.optionalWith<typeof SwarmEndpoint.SwarmEndpoint, {
+        nullable: true;
+    }>;
+    UpdateStatus: Schema.optionalWith<typeof SwarmUpdateStatus.SwarmUpdateStatus, {
+        nullable: true;
+    }>;
+    ServiceStatus: Schema.optionalWith<typeof SwarmServiceStatus.SwarmServiceStatus, {
+        nullable: true;
+    }>;
+    JobStatus: Schema.optionalWith<typeof SwarmJobStatus.SwarmJobStatus, {
+        nullable: true;
+    }>;
+    Version: Schema.optionalWith<typeof import("./SwarmVersion.generated.js").SwarmVersion, {
+        nullable: true;
+    }>;
+    CreatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    UpdatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    ID: typeof Schema.String;
+}>, never, {
+    readonly ID: string;
+} & {
+    readonly CreatedAt?: Date | undefined;
+} & {
+    readonly Version?: import("./SwarmVersion.generated.js").SwarmVersion | undefined;
+} & {
+    readonly UpdatedAt?: Date | undefined;
+} & {
+    readonly Spec?: SwarmServiceSpec.SwarmServiceSpec | undefined;
+} & {
+    readonly PreviousSpec?: SwarmServiceSpec.SwarmServiceSpec | undefined;
+} & {
+    readonly Endpoint?: SwarmEndpoint.SwarmEndpoint | undefined;
+} & {
+    readonly UpdateStatus?: SwarmUpdateStatus.SwarmUpdateStatus | undefined;
+} & {
+    readonly ServiceStatus?: SwarmServiceStatus.SwarmServiceStatus | undefined;
+} & {
+    readonly JobStatus?: SwarmJobStatus.SwarmJobStatus | undefined;
+}, {}, {}>;
+export declare class SwarmService extends SwarmService_base {
+}
+export {};
+//# sourceMappingURL=SwarmService.generated.d.ts.map

package/dist/dts/internal/generated/SwarmService.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmService.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmService.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,aAAa,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,cAAc,MAAM,+BAA+B,CAAC;AAEhE,OAAO,KAAK,gBAAgB,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,kBAAkB,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,iBAAiB,MAAM,kCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtE,qBAAa,YAAa,SAAQ,iBAiBjC;CAAG"}

package/dist/dts/internal/generated/SwarmServiceCreateResponse.generated.d.ts

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+declare const SwarmServiceCreateResponse_base: Schema.Class<SwarmServiceCreateResponse, {
+    ID: Schema.optional<typeof Schema.String>;
+    Warnings: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+}, Schema.Struct.Encoded<{
+    ID: Schema.optional<typeof Schema.String>;
+    Warnings: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+}>, never, {
+    readonly ID?: string | undefined;
+} & {
+    readonly Warnings: readonly string[] | null;
+}, {}, {}>;
+export declare class SwarmServiceCreateResponse extends SwarmServiceCreateResponse_base {
+}
+export {};
+//# sourceMappingURL=SwarmServiceCreateResponse.generated.d.ts.map

package/dist/dts/internal/generated/SwarmServiceCreateResponse.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmServiceCreateResponse.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmServiceCreateResponse.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;;;;;AAExC,qBAAa,0BAA2B,SAAQ,+BAW/C;CAAG"}

package/dist/dts/internal/generated/SwarmServiceMode.generated.d.ts

@@ -0,0 +1,44 @@
+import * as Schema from "effect/Schema";
+import * as SwarmGlobalJob from "./SwarmGlobalJob.generated.js";
+import * as SwarmGlobalService from "./SwarmGlobalService.generated.js";
+import * as SwarmReplicatedJob from "./SwarmReplicatedJob.generated.js";
+import * as SwarmReplicatedService from "./SwarmReplicatedService.generated.js";
+declare const SwarmServiceMode_base: Schema.Class<SwarmServiceMode, {
+    Replicated: Schema.optionalWith<typeof SwarmReplicatedService.SwarmReplicatedService, {
+        nullable: true;
+    }>;
+    Global: Schema.optionalWith<typeof SwarmGlobalService.SwarmGlobalService, {
+        nullable: true;
+    }>;
+    ReplicatedJob: Schema.optionalWith<typeof SwarmReplicatedJob.SwarmReplicatedJob, {
+        nullable: true;
+    }>;
+    GlobalJob: Schema.optionalWith<typeof SwarmGlobalJob.SwarmGlobalJob, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    Replicated: Schema.optionalWith<typeof SwarmReplicatedService.SwarmReplicatedService, {
+        nullable: true;
+    }>;
+    Global: Schema.optionalWith<typeof SwarmGlobalService.SwarmGlobalService, {
+        nullable: true;
+    }>;
+    ReplicatedJob: Schema.optionalWith<typeof SwarmReplicatedJob.SwarmReplicatedJob, {
+        nullable: true;
+    }>;
+    GlobalJob: Schema.optionalWith<typeof SwarmGlobalJob.SwarmGlobalJob, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly Replicated?: SwarmReplicatedService.SwarmReplicatedService | undefined;
+} & {
+    readonly Global?: SwarmGlobalService.SwarmGlobalService | undefined;
+} & {
+    readonly ReplicatedJob?: SwarmReplicatedJob.SwarmReplicatedJob | undefined;
+} & {
+    readonly GlobalJob?: SwarmGlobalJob.SwarmGlobalJob | undefined;
+}, {}, {}>;
+export declare class SwarmServiceMode extends SwarmServiceMode_base {
+}
+export {};
+//# sourceMappingURL=SwarmServiceMode.generated.d.ts.map

package/dist/dts/internal/generated/SwarmServiceMode.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmServiceMode.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmServiceMode.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,cAAc,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,kBAAkB,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,kBAAkB,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,sBAAsB,MAAM,uCAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhF,qBAAa,gBAAiB,SAAQ,qBAarC;CAAG"}

package/dist/dts/internal/generated/SwarmServiceSpec.generated.d.ts

@@ -0,0 +1,71 @@
+import * as Schema from "effect/Schema";
+import * as SwarmEndpointSpec from "./SwarmEndpointSpec.generated.js";
+import * as SwarmNetworkAttachmentConfig from "./SwarmNetworkAttachmentConfig.generated.js";
+import * as SwarmServiceMode from "./SwarmServiceMode.generated.js";
+import * as SwarmTaskSpec from "./SwarmTaskSpec.generated.js";
+import * as SwarmUpdateConfig from "./SwarmUpdateConfig.generated.js";
+declare const SwarmServiceSpec_base: Schema.Class<SwarmServiceSpec, {
+    TaskTemplate: Schema.optionalWith<typeof SwarmTaskSpec.SwarmTaskSpec, {
+        nullable: true;
+    }>;
+    Mode: Schema.optionalWith<typeof SwarmServiceMode.SwarmServiceMode, {
+        nullable: true;
+    }>;
+    UpdateConfig: Schema.optionalWith<typeof SwarmUpdateConfig.SwarmUpdateConfig, {
+        nullable: true;
+    }>;
+    RollbackConfig: Schema.optionalWith<typeof SwarmUpdateConfig.SwarmUpdateConfig, {
+        nullable: true;
+    }>;
+    Networks: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmNetworkAttachmentConfig.SwarmNetworkAttachmentConfig>>, {
+        nullable: true;
+    }>;
+    EndpointSpec: Schema.optionalWith<typeof SwarmEndpointSpec.SwarmEndpointSpec, {
+        nullable: true;
+    }>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}, Schema.Struct.Encoded<{
+    TaskTemplate: Schema.optionalWith<typeof SwarmTaskSpec.SwarmTaskSpec, {
+        nullable: true;
+    }>;
+    Mode: Schema.optionalWith<typeof SwarmServiceMode.SwarmServiceMode, {
+        nullable: true;
+    }>;
+    UpdateConfig: Schema.optionalWith<typeof SwarmUpdateConfig.SwarmUpdateConfig, {
+        nullable: true;
+    }>;
+    RollbackConfig: Schema.optionalWith<typeof SwarmUpdateConfig.SwarmUpdateConfig, {
+        nullable: true;
+    }>;
+    Networks: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmNetworkAttachmentConfig.SwarmNetworkAttachmentConfig>>, {
+        nullable: true;
+    }>;
+    EndpointSpec: Schema.optionalWith<typeof SwarmEndpointSpec.SwarmEndpointSpec, {
+        nullable: true;
+    }>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}>, never, {
+    readonly Name?: string | undefined;
+} & {
+    readonly Labels: {
+        readonly [x: string]: string;
+    } | null;
+} & {
+    readonly Mode?: SwarmServiceMode.SwarmServiceMode | undefined;
+} & {
+    readonly Networks?: readonly (SwarmNetworkAttachmentConfig.SwarmNetworkAttachmentConfig | null)[] | undefined;
+} & {
+    readonly TaskTemplate?: SwarmTaskSpec.SwarmTaskSpec | undefined;
+} & {
+    readonly UpdateConfig?: SwarmUpdateConfig.SwarmUpdateConfig | undefined;
+} & {
+    readonly RollbackConfig?: SwarmUpdateConfig.SwarmUpdateConfig | undefined;
+} & {
+    readonly EndpointSpec?: SwarmEndpointSpec.SwarmEndpointSpec | undefined;
+}, {}, {}>;
+export declare class SwarmServiceSpec extends SwarmServiceSpec_base {
+}
+export {};
+//# sourceMappingURL=SwarmServiceSpec.generated.d.ts.map

package/dist/dts/internal/generated/SwarmServiceSpec.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmServiceSpec.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmServiceSpec.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,iBAAiB,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,4BAA4B,MAAM,6CAA6C,CAAC;AAC5F,OAAO,KAAK,gBAAgB,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,aAAa,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,iBAAiB,MAAM,kCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtE,qBAAa,gBAAiB,SAAQ,qBAqBrC;CAAG"}

package/dist/dts/internal/generated/SwarmServiceStatus.generated.d.ts

@@ -0,0 +1,21 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+declare const SwarmServiceStatus_base: Schema.Class<SwarmServiceStatus, {
+    RunningTasks: MobySchemas.UInt64Schemas.$UInt64;
+    DesiredTasks: MobySchemas.UInt64Schemas.$UInt64;
+    CompletedTasks: MobySchemas.UInt64Schemas.$UInt64;
+}, Schema.Struct.Encoded<{
+    RunningTasks: MobySchemas.UInt64Schemas.$UInt64;
+    DesiredTasks: MobySchemas.UInt64Schemas.$UInt64;
+    CompletedTasks: MobySchemas.UInt64Schemas.$UInt64;
+}>, never, {
+    readonly RunningTasks: MobySchemas.UInt64Schemas.UInt64Brand;
+} & {
+    readonly DesiredTasks: MobySchemas.UInt64Schemas.UInt64Brand;
+} & {
+    readonly CompletedTasks: MobySchemas.UInt64Schemas.UInt64Brand;
+}, {}, {}>;
+export declare class SwarmServiceStatus extends SwarmServiceStatus_base {
+}
+export {};
+//# sourceMappingURL=SwarmServiceStatus.generated.d.ts.map

package/dist/dts/internal/generated/SwarmServiceStatus.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmServiceStatus.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmServiceStatus.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;;;;;;;;;;;;;;;;AAEnD,qBAAa,kBAAmB,SAAQ,uBAYvC;CAAG"}

package/dist/dts/internal/generated/SwarmServiceUpdateResponse.generated.d.ts

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+declare const SwarmServiceUpdateResponse_base: Schema.Class<SwarmServiceUpdateResponse, {
+    Warnings: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+}, Schema.Struct.Encoded<{
+    Warnings: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+}>, never, {
+    readonly Warnings: readonly string[] | null;
+}, {}, {}>;
+export declare class SwarmServiceUpdateResponse extends SwarmServiceUpdateResponse_base {
+}
+export {};
+//# sourceMappingURL=SwarmServiceUpdateResponse.generated.d.ts.map

package/dist/dts/internal/generated/SwarmServiceUpdateResponse.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmServiceUpdateResponse.generated.d.ts","sourceRoot":"","sources":["../../../../src/internal/generated/SwarmServiceUpdateResponse.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;AAExC,qBAAa,0BAA2B,SAAQ,+BAU/C;CAAG"}