the-moby-effect 1.48.4 → 1.51.1

package/dist/internal/generated/SwarmService.generated.js

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import * as SwarmEndpoint from "./SwarmEndpoint.generated.js";
+import * as SwarmJobStatus from "./SwarmJobStatus.generated.js";
+import * as SwarmMeta from "./SwarmMeta.generated.js";
+import * as SwarmServiceSpec from "./SwarmServiceSpec.generated.js";
+import * as SwarmServiceStatus from "./SwarmServiceStatus.generated.js";
+import * as SwarmUpdateStatus from "./SwarmUpdateStatus.generated.js";
+export class SwarmService extends /*#__PURE__*/Schema.Class("SwarmService")({
+  ID: Schema.String,
+  ...SwarmMeta.SwarmMeta.fields,
+  Spec: /*#__PURE__*/Schema.optionalWith(SwarmServiceSpec.SwarmServiceSpec, {
+    nullable: true
+  }),
+  PreviousSpec: /*#__PURE__*/Schema.optionalWith(SwarmServiceSpec.SwarmServiceSpec, {
+    nullable: true
+  }),
+  Endpoint: /*#__PURE__*/Schema.optionalWith(SwarmEndpoint.SwarmEndpoint, {
+    nullable: true
+  }),
+  UpdateStatus: /*#__PURE__*/Schema.optionalWith(SwarmUpdateStatus.SwarmUpdateStatus, {
+    nullable: true
+  }),
+  ServiceStatus: /*#__PURE__*/Schema.optionalWith(SwarmServiceStatus.SwarmServiceStatus, {
+    nullable: true
+  }),
+  JobStatus: /*#__PURE__*/Schema.optionalWith(SwarmJobStatus.SwarmJobStatus, {
+    nullable: true
+  })
+}, {
+  identifier: "SwarmService",
+  title: "swarm.Service",
+  documentation: "https://pkg.go.dev/github.com/docker/docker@v28.4.0+incompatible/api/types/swarm#Service"
+}) {}
+//# sourceMappingURL=SwarmService.generated.js.map

package/dist/internal/generated/SwarmService.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmService.generated.js","names":["Schema","SwarmEndpoint","SwarmJobStatus","SwarmMeta","SwarmServiceSpec","SwarmServiceStatus","SwarmUpdateStatus","SwarmService","Class","ID","String","fields","Spec","optionalWith","nullable","PreviousSpec","Endpoint","UpdateStatus","ServiceStatus","JobStatus","identifier","title","documentation"],"sources":["../../../src/internal/generated/SwarmService.generated.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,aAAa,MAAM,8BAA8B;AAC7D,OAAO,KAAKC,cAAc,MAAM,+BAA+B;AAC/D,OAAO,KAAKC,SAAS,MAAM,0BAA0B;AACrD,OAAO,KAAKC,gBAAgB,MAAM,iCAAiC;AACnE,OAAO,KAAKC,kBAAkB,MAAM,mCAAmC;AACvE,OAAO,KAAKC,iBAAiB,MAAM,kCAAkC;AAErE,OAAM,MAAOC,YAAa,sBAAQP,MAAM,CAACQ,KAAK,CAAe,cAAc,CAAC,CACxE;EACIC,EAAE,EAAET,MAAM,CAACU,MAAM;EACjB,GAAGP,SAAS,CAACA,SAAS,CAACQ,MAAM;EAC7BC,IAAI,eAAEZ,MAAM,CAACa,YAAY,CAACT,gBAAgB,CAACA,gBAAgB,EAAE;IAAEU,QAAQ,EAAE;EAAI,CAAE,CAAC;EAChFC,YAAY,eAAEf,MAAM,CAACa,YAAY,CAACT,gBAAgB,CAACA,gBAAgB,EAAE;IAAEU,QAAQ,EAAE;EAAI,CAAE,CAAC;EACxFE,QAAQ,eAAEhB,MAAM,CAACa,YAAY,CAACZ,aAAa,CAACA,aAAa,EAAE;IAAEa,QAAQ,EAAE;EAAI,CAAE,CAAC;EAC9EG,YAAY,eAAEjB,MAAM,CAACa,YAAY,CAACP,iBAAiB,CAACA,iBAAiB,EAAE;IAAEQ,QAAQ,EAAE;EAAI,CAAE,CAAC;EAC1FI,aAAa,eAAElB,MAAM,CAACa,YAAY,CAACR,kBAAkB,CAACA,kBAAkB,EAAE;IAAES,QAAQ,EAAE;EAAI,CAAE,CAAC;EAC7FK,SAAS,eAAEnB,MAAM,CAACa,YAAY,CAACX,cAAc,CAACA,cAAc,EAAE;IAAEY,QAAQ,EAAE;EAAI,CAAE;CACnF,EACD;EACIM,UAAU,EAAE,cAAc;EAC1BC,KAAK,EAAE,eAAe;EACtBC,aAAa,EAAE;CAClB,CACJ","ignoreList":[]}

package/dist/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,qBAYrC;CAAG"}

package/dist/internal/generated/SwarmServiceMode.generated.js

@@ -0,0 +1,24 @@
+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";
+export class SwarmServiceMode extends /*#__PURE__*/Schema.Class("SwarmServiceMode")({
+  Replicated: /*#__PURE__*/Schema.optionalWith(SwarmReplicatedService.SwarmReplicatedService, {
+    nullable: true
+  }),
+  Global: /*#__PURE__*/Schema.optionalWith(SwarmGlobalService.SwarmGlobalService, {
+    nullable: true
+  }),
+  ReplicatedJob: /*#__PURE__*/Schema.optionalWith(SwarmReplicatedJob.SwarmReplicatedJob, {
+    nullable: true
+  }),
+  GlobalJob: /*#__PURE__*/Schema.optionalWith(SwarmGlobalJob.SwarmGlobalJob, {
+    nullable: true
+  })
+}, {
+  identifier: "SwarmServiceMode",
+  title: "swarm.ServiceMode",
+  documentation: "https://pkg.go.dev/github.com/docker/docker@v28.4.0+incompatible/api/types/swarm#ServiceMode"
+}) {}
+//# sourceMappingURL=SwarmServiceMode.generated.js.map

package/dist/internal/generated/SwarmServiceMode.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmServiceMode.generated.js","names":["Schema","SwarmGlobalJob","SwarmGlobalService","SwarmReplicatedJob","SwarmReplicatedService","SwarmServiceMode","Class","Replicated","optionalWith","nullable","Global","ReplicatedJob","GlobalJob","identifier","title","documentation"],"sources":["../../../src/internal/generated/SwarmServiceMode.generated.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,cAAc,MAAM,+BAA+B;AAC/D,OAAO,KAAKC,kBAAkB,MAAM,mCAAmC;AACvE,OAAO,KAAKC,kBAAkB,MAAM,mCAAmC;AACvE,OAAO,KAAKC,sBAAsB,MAAM,uCAAuC;AAE/E,OAAM,MAAOC,gBAAiB,sBAAQL,MAAM,CAACM,KAAK,CAAmB,kBAAkB,CAAC,CACpF;EACIC,UAAU,eAAEP,MAAM,CAACQ,YAAY,CAACJ,sBAAsB,CAACA,sBAAsB,EAAE;IAAEK,QAAQ,EAAE;EAAI,CAAE,CAAC;EAClGC,MAAM,eAAEV,MAAM,CAACQ,YAAY,CAACN,kBAAkB,CAACA,kBAAkB,EAAE;IAAEO,QAAQ,EAAE;EAAI,CAAE,CAAC;EACtFE,aAAa,eAAEX,MAAM,CAACQ,YAAY,CAACL,kBAAkB,CAACA,kBAAkB,EAAE;IAAEM,QAAQ,EAAE;EAAI,CAAE,CAAC;EAC7FG,SAAS,eAAEZ,MAAM,CAACQ,YAAY,CAACP,cAAc,CAACA,cAAc,EAAE;IAAEQ,QAAQ,EAAE;EAAI,CAAE;CACnF,EACD;EACII,UAAU,EAAE,kBAAkB;EAC9BC,KAAK,EAAE,mBAAmB;EAC1BC,aAAa,EAAE;CAClB,CACJ","ignoreList":[]}

package/dist/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 Labels: {
+        readonly [x: string]: string;
+    } | null;
+} & {
+    readonly Name?: string | undefined;
+} & {
+    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/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,qBAkBrC;CAAG"}

package/dist/internal/generated/SwarmServiceSpec.generated.js

@@ -0,0 +1,33 @@
+import * as Schema from "effect/Schema";
+import * as SwarmAnnotations from "./SwarmAnnotations.generated.js";
+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";
+export class SwarmServiceSpec extends /*#__PURE__*/Schema.Class("SwarmServiceSpec")({
+  ...SwarmAnnotations.SwarmAnnotations.fields,
+  TaskTemplate: /*#__PURE__*/Schema.optionalWith(SwarmTaskSpec.SwarmTaskSpec, {
+    nullable: true
+  }),
+  Mode: /*#__PURE__*/Schema.optionalWith(SwarmServiceMode.SwarmServiceMode, {
+    nullable: true
+  }),
+  UpdateConfig: /*#__PURE__*/Schema.optionalWith(SwarmUpdateConfig.SwarmUpdateConfig, {
+    nullable: true
+  }),
+  RollbackConfig: /*#__PURE__*/Schema.optionalWith(SwarmUpdateConfig.SwarmUpdateConfig, {
+    nullable: true
+  }),
+  Networks: /*#__PURE__*/Schema.optionalWith(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.NullOr(SwarmNetworkAttachmentConfig.SwarmNetworkAttachmentConfig)), {
+    nullable: true
+  }),
+  EndpointSpec: /*#__PURE__*/Schema.optionalWith(SwarmEndpointSpec.SwarmEndpointSpec, {
+    nullable: true
+  })
+}, {
+  identifier: "SwarmServiceSpec",
+  title: "swarm.ServiceSpec",
+  documentation: "https://pkg.go.dev/github.com/docker/docker@v28.4.0+incompatible/api/types/swarm#ServiceSpec"
+}) {}
+//# sourceMappingURL=SwarmServiceSpec.generated.js.map

package/dist/internal/generated/SwarmServiceSpec.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmServiceSpec.generated.js","names":["Schema","SwarmAnnotations","SwarmEndpointSpec","SwarmNetworkAttachmentConfig","SwarmServiceMode","SwarmTaskSpec","SwarmUpdateConfig","SwarmServiceSpec","Class","fields","TaskTemplate","optionalWith","nullable","Mode","UpdateConfig","RollbackConfig","Networks","Array","NullOr","EndpointSpec","identifier","title","documentation"],"sources":["../../../src/internal/generated/SwarmServiceSpec.generated.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,gBAAgB,MAAM,iCAAiC;AACnE,OAAO,KAAKC,iBAAiB,MAAM,kCAAkC;AACrE,OAAO,KAAKC,4BAA4B,MAAM,6CAA6C;AAC3F,OAAO,KAAKC,gBAAgB,MAAM,iCAAiC;AACnE,OAAO,KAAKC,aAAa,MAAM,8BAA8B;AAC7D,OAAO,KAAKC,iBAAiB,MAAM,kCAAkC;AAErE,OAAM,MAAOC,gBAAiB,sBAAQP,MAAM,CAACQ,KAAK,CAAmB,kBAAkB,CAAC,CACpF;EACI,GAAGP,gBAAgB,CAACA,gBAAgB,CAACQ,MAAM;EAC3CC,YAAY,eAAEV,MAAM,CAACW,YAAY,CAACN,aAAa,CAACA,aAAa,EAAE;IAAEO,QAAQ,EAAE;EAAI,CAAE,CAAC;EAClFC,IAAI,eAAEb,MAAM,CAACW,YAAY,CAACP,gBAAgB,CAACA,gBAAgB,EAAE;IAAEQ,QAAQ,EAAE;EAAI,CAAE,CAAC;EAChFE,YAAY,eAAEd,MAAM,CAACW,YAAY,CAACL,iBAAiB,CAACA,iBAAiB,EAAE;IAAEM,QAAQ,EAAE;EAAI,CAAE,CAAC;EAC1FG,cAAc,eAAEf,MAAM,CAACW,YAAY,CAACL,iBAAiB,CAACA,iBAAiB,EAAE;IAAEM,QAAQ,EAAE;EAAI,CAAE,CAAC;EAC5FI,QAAQ,eAAEhB,MAAM,CAACW,YAAY,cACzBX,MAAM,CAACiB,KAAK,cAACjB,MAAM,CAACkB,MAAM,CAACf,4BAA4B,CAACA,4BAA4B,CAAC,CAAC,EACtF;IAAES,QAAQ,EAAE;EAAI,CAAE,CACrB;EACDO,YAAY,eAAEnB,MAAM,CAACW,YAAY,CAACT,iBAAiB,CAACA,iBAAiB,EAAE;IAAEU,QAAQ,EAAE;EAAI,CAAE;CAC5F,EACD;EACIQ,UAAU,EAAE,kBAAkB;EAC9BC,KAAK,EAAE,mBAAmB;EAC1BC,aAAa,EAAE;CAClB,CACJ","ignoreList":[]}

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

@@ -0,0 +1,21 @@
+import * as EffectSchemas from "effect-schemas";
+import * as Schema from "effect/Schema";
+declare const SwarmServiceStatus_base: Schema.Class<SwarmServiceStatus, {
+    RunningTasks: typeof EffectSchemas.Number.U64;
+    DesiredTasks: typeof EffectSchemas.Number.U64;
+    CompletedTasks: typeof EffectSchemas.Number.U64;
+}, Schema.Struct.Encoded<{
+    RunningTasks: typeof EffectSchemas.Number.U64;
+    DesiredTasks: typeof EffectSchemas.Number.U64;
+    CompletedTasks: typeof EffectSchemas.Number.U64;
+}>, never, {
+    readonly RunningTasks: bigint & import("effect/Brand").Brand<"U64">;
+} & {
+    readonly DesiredTasks: bigint & import("effect/Brand").Brand<"U64">;
+} & {
+    readonly CompletedTasks: bigint & import("effect/Brand").Brand<"U64">;
+}, {}, {}>;
+export declare class SwarmServiceStatus extends SwarmServiceStatus_base {
+}
+export {};
+//# sourceMappingURL=SwarmServiceStatus.generated.d.ts.map

package/dist/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,aAAa,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;AAExC,qBAAa,kBAAmB,SAAQ,uBAWvC;CAAG"}

package/dist/internal/generated/SwarmServiceStatus.generated.js

@@ -0,0 +1,12 @@
+import * as EffectSchemas from "effect-schemas";
+import * as Schema from "effect/Schema";
+export class SwarmServiceStatus extends /*#__PURE__*/Schema.Class("SwarmServiceStatus")({
+  RunningTasks: EffectSchemas.Number.U64,
+  DesiredTasks: EffectSchemas.Number.U64,
+  CompletedTasks: EffectSchemas.Number.U64
+}, {
+  identifier: "SwarmServiceStatus",
+  title: "swarm.ServiceStatus",
+  documentation: "https://pkg.go.dev/github.com/docker/docker@v28.4.0+incompatible/api/types/swarm#ServiceStatus"
+}) {}
+//# sourceMappingURL=SwarmServiceStatus.generated.js.map

package/dist/internal/generated/SwarmServiceStatus.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmServiceStatus.generated.js","names":["EffectSchemas","Schema","SwarmServiceStatus","Class","RunningTasks","Number","U64","DesiredTasks","CompletedTasks","identifier","title","documentation"],"sources":["../../../src/internal/generated/SwarmServiceStatus.generated.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,aAAa,MAAM,gBAAgB;AAC/C,OAAO,KAAKC,MAAM,MAAM,eAAe;AAEvC,OAAM,MAAOC,kBAAmB,sBAAQD,MAAM,CAACE,KAAK,CAAqB,oBAAoB,CAAC,CAC1F;EACIC,YAAY,EAAEJ,aAAa,CAACK,MAAM,CAACC,GAAG;EACtCC,YAAY,EAAEP,aAAa,CAACK,MAAM,CAACC,GAAG;EACtCE,cAAc,EAAER,aAAa,CAACK,MAAM,CAACC;CACxC,EACD;EACIG,UAAU,EAAE,oBAAoB;EAChCC,KAAK,EAAE,qBAAqB;EAC5BC,aAAa,EAAE;CAClB,CACJ","ignoreList":[]}

package/dist/internal/generated/SwarmSpec.generated.d.ts

@@ -0,0 +1,72 @@
+import * as Schema from "effect/Schema";
+import * as SwarmCAConfig from "./SwarmCAConfig.generated.js";
+import * as SwarmDispatcherConfig from "./SwarmDispatcherConfig.generated.js";
+import * as SwarmEncryptionConfig from "./SwarmEncryptionConfig.generated.js";
+import * as SwarmOrchestrationConfig from "./SwarmOrchestrationConfig.generated.js";
+import * as SwarmRaftConfig from "./SwarmRaftConfig.generated.js";
+import * as SwarmTaskDefaults from "./SwarmTaskDefaults.generated.js";
+declare const SwarmSpec_base: Schema.Class<SwarmSpec, {
+    Orchestration: Schema.optionalWith<typeof SwarmOrchestrationConfig.SwarmOrchestrationConfig, {
+        nullable: true;
+    }>;
+    Raft: Schema.optionalWith<typeof SwarmRaftConfig.SwarmRaftConfig, {
+        nullable: true;
+    }>;
+    Dispatcher: Schema.optionalWith<typeof SwarmDispatcherConfig.SwarmDispatcherConfig, {
+        nullable: true;
+    }>;
+    CAConfig: Schema.optionalWith<typeof SwarmCAConfig.SwarmCAConfig, {
+        nullable: true;
+    }>;
+    TaskDefaults: Schema.optionalWith<typeof SwarmTaskDefaults.SwarmTaskDefaults, {
+        nullable: true;
+    }>;
+    EncryptionConfig: Schema.optionalWith<typeof SwarmEncryptionConfig.SwarmEncryptionConfig, {
+        nullable: true;
+    }>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}, Schema.Struct.Encoded<{
+    Orchestration: Schema.optionalWith<typeof SwarmOrchestrationConfig.SwarmOrchestrationConfig, {
+        nullable: true;
+    }>;
+    Raft: Schema.optionalWith<typeof SwarmRaftConfig.SwarmRaftConfig, {
+        nullable: true;
+    }>;
+    Dispatcher: Schema.optionalWith<typeof SwarmDispatcherConfig.SwarmDispatcherConfig, {
+        nullable: true;
+    }>;
+    CAConfig: Schema.optionalWith<typeof SwarmCAConfig.SwarmCAConfig, {
+        nullable: true;
+    }>;
+    TaskDefaults: Schema.optionalWith<typeof SwarmTaskDefaults.SwarmTaskDefaults, {
+        nullable: true;
+    }>;
+    EncryptionConfig: Schema.optionalWith<typeof SwarmEncryptionConfig.SwarmEncryptionConfig, {
+        nullable: true;
+    }>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}>, never, {
+    readonly Labels: {
+        readonly [x: string]: string;
+    } | null;
+} & {
+    readonly Name?: string | undefined;
+} & {
+    readonly Orchestration?: SwarmOrchestrationConfig.SwarmOrchestrationConfig | undefined;
+} & {
+    readonly Raft?: SwarmRaftConfig.SwarmRaftConfig | undefined;
+} & {
+    readonly Dispatcher?: SwarmDispatcherConfig.SwarmDispatcherConfig | undefined;
+} & {
+    readonly CAConfig?: SwarmCAConfig.SwarmCAConfig | undefined;
+} & {
+    readonly TaskDefaults?: SwarmTaskDefaults.SwarmTaskDefaults | undefined;
+} & {
+    readonly EncryptionConfig?: SwarmEncryptionConfig.SwarmEncryptionConfig | undefined;
+}, {}, {}>;
+export declare class SwarmSpec extends SwarmSpec_base {
+}
+export {};
+//# sourceMappingURL=SwarmSpec.generated.d.ts.map

package/dist/internal/generated/SwarmSpec.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSpec.generated.d.ts","sourceRoot":"","sources":["../../../src/internal/generated/SwarmSpec.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,aAAa,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,qBAAqB,MAAM,sCAAsC,CAAC;AAC9E,OAAO,KAAK,qBAAqB,MAAM,sCAAsC,CAAC;AAC9E,OAAO,KAAK,wBAAwB,MAAM,yCAAyC,CAAC;AACpF,OAAO,KAAK,eAAe,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,iBAAiB,MAAM,kCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtE,qBAAa,SAAU,SAAQ,cAe9B;CAAG"}

package/dist/internal/generated/SwarmSpec.generated.js

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import * as SwarmAnnotations from "./SwarmAnnotations.generated.js";
+import * as SwarmCAConfig from "./SwarmCAConfig.generated.js";
+import * as SwarmDispatcherConfig from "./SwarmDispatcherConfig.generated.js";
+import * as SwarmEncryptionConfig from "./SwarmEncryptionConfig.generated.js";
+import * as SwarmOrchestrationConfig from "./SwarmOrchestrationConfig.generated.js";
+import * as SwarmRaftConfig from "./SwarmRaftConfig.generated.js";
+import * as SwarmTaskDefaults from "./SwarmTaskDefaults.generated.js";
+export class SwarmSpec extends /*#__PURE__*/Schema.Class("SwarmSpec")({
+  ...SwarmAnnotations.SwarmAnnotations.fields,
+  Orchestration: /*#__PURE__*/Schema.optionalWith(SwarmOrchestrationConfig.SwarmOrchestrationConfig, {
+    nullable: true
+  }),
+  Raft: /*#__PURE__*/Schema.optionalWith(SwarmRaftConfig.SwarmRaftConfig, {
+    nullable: true
+  }),
+  Dispatcher: /*#__PURE__*/Schema.optionalWith(SwarmDispatcherConfig.SwarmDispatcherConfig, {
+    nullable: true
+  }),
+  CAConfig: /*#__PURE__*/Schema.optionalWith(SwarmCAConfig.SwarmCAConfig, {
+    nullable: true
+  }),
+  TaskDefaults: /*#__PURE__*/Schema.optionalWith(SwarmTaskDefaults.SwarmTaskDefaults, {
+    nullable: true
+  }),
+  EncryptionConfig: /*#__PURE__*/Schema.optionalWith(SwarmEncryptionConfig.SwarmEncryptionConfig, {
+    nullable: true
+  })
+}, {
+  identifier: "SwarmSpec",
+  title: "swarm.Spec",
+  documentation: "https://pkg.go.dev/github.com/docker/docker@v28.4.0+incompatible/api/types/swarm#Spec"
+}) {}
+//# sourceMappingURL=SwarmSpec.generated.js.map

package/dist/internal/generated/SwarmSpec.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSpec.generated.js","names":["Schema","SwarmAnnotations","SwarmCAConfig","SwarmDispatcherConfig","SwarmEncryptionConfig","SwarmOrchestrationConfig","SwarmRaftConfig","SwarmTaskDefaults","SwarmSpec","Class","fields","Orchestration","optionalWith","nullable","Raft","Dispatcher","CAConfig","TaskDefaults","EncryptionConfig","identifier","title","documentation"],"sources":["../../../src/internal/generated/SwarmSpec.generated.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,gBAAgB,MAAM,iCAAiC;AACnE,OAAO,KAAKC,aAAa,MAAM,8BAA8B;AAC7D,OAAO,KAAKC,qBAAqB,MAAM,sCAAsC;AAC7E,OAAO,KAAKC,qBAAqB,MAAM,sCAAsC;AAC7E,OAAO,KAAKC,wBAAwB,MAAM,yCAAyC;AACnF,OAAO,KAAKC,eAAe,MAAM,gCAAgC;AACjE,OAAO,KAAKC,iBAAiB,MAAM,kCAAkC;AAErE,OAAM,MAAOC,SAAU,sBAAQR,MAAM,CAACS,KAAK,CAAY,WAAW,CAAC,CAC/D;EACI,GAAGR,gBAAgB,CAACA,gBAAgB,CAACS,MAAM;EAC3CC,aAAa,eAAEX,MAAM,CAACY,YAAY,CAACP,wBAAwB,CAACA,wBAAwB,EAAE;IAAEQ,QAAQ,EAAE;EAAI,CAAE,CAAC;EACzGC,IAAI,eAAEd,MAAM,CAACY,YAAY,CAACN,eAAe,CAACA,eAAe,EAAE;IAAEO,QAAQ,EAAE;EAAI,CAAE,CAAC;EAC9EE,UAAU,eAAEf,MAAM,CAACY,YAAY,CAACT,qBAAqB,CAACA,qBAAqB,EAAE;IAAEU,QAAQ,EAAE;EAAI,CAAE,CAAC;EAChGG,QAAQ,eAAEhB,MAAM,CAACY,YAAY,CAACV,aAAa,CAACA,aAAa,EAAE;IAAEW,QAAQ,EAAE;EAAI,CAAE,CAAC;EAC9EI,YAAY,eAAEjB,MAAM,CAACY,YAAY,CAACL,iBAAiB,CAACA,iBAAiB,EAAE;IAAEM,QAAQ,EAAE;EAAI,CAAE,CAAC;EAC1FK,gBAAgB,eAAElB,MAAM,CAACY,YAAY,CAACR,qBAAqB,CAACA,qBAAqB,EAAE;IAAES,QAAQ,EAAE;EAAI,CAAE;CACxG,EACD;EACIM,UAAU,EAAE,WAAW;EACvBC,KAAK,EAAE,YAAY;EACnBC,aAAa,EAAE;CAClB,CACJ","ignoreList":[]}

package/dist/internal/generated/SwarmSpreadOver.generated.d.ts.map

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

package/dist/internal/generated/SwarmSpreadOver.generated.js

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+export class SwarmSpreadOver extends /*#__PURE__*/Schema.Class("SwarmSpreadOver")({
+  SpreadDescriptor: Schema.String
+}, {
+  identifier: "SwarmSpreadOver",
+  title: "swarm.SpreadOver",
+  documentation: "https://pkg.go.dev/github.com/docker/docker@v28.4.0+incompatible/api/types/swarm#SpreadOver"
+}) {}
+//# sourceMappingURL=SwarmSpreadOver.generated.js.map

package/dist/internal/generated/SwarmSpreadOver.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSpreadOver.generated.js","names":["Schema","SwarmSpreadOver","Class","SpreadDescriptor","String","identifier","title","documentation"],"sources":["../../../src/internal/generated/SwarmSpreadOver.generated.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,eAAe;AAEvC,OAAM,MAAOC,eAAgB,sBAAQD,MAAM,CAACE,KAAK,CAAkB,iBAAiB,CAAC,CACjF;EACIC,gBAAgB,EAAEH,MAAM,CAACI;CAC5B,EACD;EACIC,UAAU,EAAE,iBAAiB;EAC7BC,KAAK,EAAE,kBAAkB;EACzBC,aAAa,EAAE;CAClB,CACJ","ignoreList":[]}

package/dist/internal/generated/SwarmSwarm.generated.d.ts

@@ -0,0 +1,65 @@
+import * as Schema from "effect/Schema";
+import * as SwarmJoinTokens from "./SwarmJoinTokens.generated.js";
+declare const SwarmSwarm_base: Schema.Class<SwarmSwarm, {
+    JoinTokens: Schema.NullOr<typeof SwarmJoinTokens.SwarmJoinTokens>;
+    Spec: Schema.NullOr<typeof import("./SwarmSpec.generated.ts").SwarmSpec>;
+    TLSInfo: Schema.NullOr<typeof import("./SwarmTLSInfo.generated.ts").SwarmTLSInfo>;
+    RootRotationInProgress: typeof Schema.Boolean;
+    DefaultAddrPool: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+    SubnetSize: typeof import("effect-schemas/Number").U32;
+    DataPathPort: typeof import("effect-schemas/Number").U32;
+    Version: Schema.optionalWith<typeof import("./SwarmVersion.generated.ts").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<{
+    JoinTokens: Schema.NullOr<typeof SwarmJoinTokens.SwarmJoinTokens>;
+    Spec: Schema.NullOr<typeof import("./SwarmSpec.generated.ts").SwarmSpec>;
+    TLSInfo: Schema.NullOr<typeof import("./SwarmTLSInfo.generated.ts").SwarmTLSInfo>;
+    RootRotationInProgress: typeof Schema.Boolean;
+    DefaultAddrPool: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+    SubnetSize: typeof import("effect-schemas/Number").U32;
+    DataPathPort: typeof import("effect-schemas/Number").U32;
+    Version: Schema.optionalWith<typeof import("./SwarmVersion.generated.ts").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.ts").SwarmVersion | undefined;
+} & {
+    readonly UpdatedAt?: Date | undefined;
+} & {
+    readonly RootRotationInProgress: boolean;
+} & {
+    readonly SubnetSize: number & import("effect/Brand").Brand<"U32">;
+} & {
+    readonly DataPathPort: number & import("effect/Brand").Brand<"U32">;
+} & {
+    readonly Spec: import("./SwarmSpec.generated.ts").SwarmSpec | null;
+} & {
+    readonly TLSInfo: import("./SwarmTLSInfo.generated.ts").SwarmTLSInfo | null;
+} & {
+    readonly DefaultAddrPool: readonly string[] | null;
+} & {
+    readonly JoinTokens: SwarmJoinTokens.SwarmJoinTokens | null;
+}, {}, {}>;
+export declare class SwarmSwarm extends SwarmSwarm_base {
+}
+export {};
+//# sourceMappingURL=SwarmSwarm.generated.d.ts.map

package/dist/internal/generated/SwarmSwarm.generated.d.ts.map

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

package/dist/internal/generated/SwarmSwarm.generated.js

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+import * as SwarmClusterInfo from "./SwarmClusterInfo.generated.js";
+import * as SwarmJoinTokens from "./SwarmJoinTokens.generated.js";
+export class SwarmSwarm extends /*#__PURE__*/Schema.Class("SwarmSwarm")({
+  ...SwarmClusterInfo.SwarmClusterInfo.fields,
+  JoinTokens: /*#__PURE__*/Schema.NullOr(SwarmJoinTokens.SwarmJoinTokens)
+}, {
+  identifier: "SwarmSwarm",
+  title: "swarm.Swarm",
+  documentation: "https://pkg.go.dev/github.com/docker/docker@v28.4.0+incompatible/api/types/swarm#Swarm"
+}) {}
+//# sourceMappingURL=SwarmSwarm.generated.js.map

package/dist/internal/generated/SwarmSwarm.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmSwarm.generated.js","names":["Schema","SwarmClusterInfo","SwarmJoinTokens","SwarmSwarm","Class","fields","JoinTokens","NullOr","identifier","title","documentation"],"sources":["../../../src/internal/generated/SwarmSwarm.generated.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,gBAAgB,MAAM,iCAAiC;AACnE,OAAO,KAAKC,eAAe,MAAM,gCAAgC;AAEjE,OAAM,MAAOC,UAAW,sBAAQH,MAAM,CAACI,KAAK,CAAa,YAAY,CAAC,CAClE;EACI,GAAGH,gBAAgB,CAACA,gBAAgB,CAACI,MAAM;EAC3CC,UAAU,eAAEN,MAAM,CAACO,MAAM,CAACL,eAAe,CAACA,eAAe;CAC5D,EACD;EACIM,UAAU,EAAE,YAAY;EACxBC,KAAK,EAAE,aAAa;EACpBC,aAAa,EAAE;CAClB,CACJ","ignoreList":[]}

package/dist/internal/generated/SwarmTLSInfo.generated.d.ts

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+declare const SwarmTLSInfo_base: Schema.Class<SwarmTLSInfo, {
+    TrustRoot: Schema.optional<typeof Schema.String>;
+    CertIssuerSubject: Schema.optionalWith<Schema.Schema<string, string, never>, {
+        nullable: true;
+    }>;
+    CertIssuerPublicKey: Schema.optionalWith<Schema.Schema<string, string, never>, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    TrustRoot: Schema.optional<typeof Schema.String>;
+    CertIssuerSubject: Schema.optionalWith<Schema.Schema<string, string, never>, {
+        nullable: true;
+    }>;
+    CertIssuerPublicKey: Schema.optionalWith<Schema.Schema<string, string, never>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly TrustRoot?: string | undefined;
+} & {
+    readonly CertIssuerSubject?: string | undefined;
+} & {
+    readonly CertIssuerPublicKey?: string | undefined;
+}, {}, {}>;
+export declare class SwarmTLSInfo extends SwarmTLSInfo_base {
+}
+export {};
+//# sourceMappingURL=SwarmTLSInfo.generated.d.ts.map

package/dist/internal/generated/SwarmTLSInfo.generated.d.ts.map

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

package/dist/internal/generated/SwarmTLSInfo.generated.js

@@ -0,0 +1,15 @@
+import * as Schema from "effect/Schema";
+export class SwarmTLSInfo extends /*#__PURE__*/Schema.Class("SwarmTLSInfo")({
+  TrustRoot: /*#__PURE__*/Schema.optional(Schema.String),
+  CertIssuerSubject: /*#__PURE__*/Schema.optionalWith(Schema.StringFromBase64, {
+    nullable: true
+  }),
+  CertIssuerPublicKey: /*#__PURE__*/Schema.optionalWith(Schema.StringFromBase64, {
+    nullable: true
+  })
+}, {
+  identifier: "SwarmTLSInfo",
+  title: "swarm.TLSInfo",
+  documentation: "https://pkg.go.dev/github.com/docker/docker@v28.4.0+incompatible/api/types/swarm#TLSInfo"
+}) {}
+//# sourceMappingURL=SwarmTLSInfo.generated.js.map

package/dist/internal/generated/SwarmTLSInfo.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmTLSInfo.generated.js","names":["Schema","SwarmTLSInfo","Class","TrustRoot","optional","String","CertIssuerSubject","optionalWith","StringFromBase64","nullable","CertIssuerPublicKey","identifier","title","documentation"],"sources":["../../../src/internal/generated/SwarmTLSInfo.generated.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,eAAe;AAEvC,OAAM,MAAOC,YAAa,sBAAQD,MAAM,CAACE,KAAK,CAAe,cAAc,CAAC,CACxE;EACIC,SAAS,eAAEH,MAAM,CAACI,QAAQ,CAACJ,MAAM,CAACK,MAAM,CAAC;EACzCC,iBAAiB,eAAEN,MAAM,CAACO,YAAY,CAACP,MAAM,CAACQ,gBAAgB,EAAE;IAAEC,QAAQ,EAAE;EAAI,CAAE,CAAC;EACnFC,mBAAmB,eAAEV,MAAM,CAACO,YAAY,CAACP,MAAM,CAACQ,gBAAgB,EAAE;IAAEC,QAAQ,EAAE;EAAI,CAAE;CACvF,EACD;EACIE,UAAU,EAAE,cAAc;EAC1BC,KAAK,EAAE,eAAe;EACtBC,aAAa,EAAE;CAClB,CACJ","ignoreList":[]}

package/dist/internal/generated/SwarmTask.generated.d.ts

@@ -0,0 +1,113 @@
+import * as EffectSchemas from "effect-schemas";
+import * as Schema from "effect/Schema";
+import * as SwarmGenericResource from "./SwarmGenericResource.generated.js";
+import * as SwarmNetworkAttachment from "./SwarmNetworkAttachment.generated.js";
+import * as SwarmTaskSpec from "./SwarmTaskSpec.generated.js";
+import * as SwarmTaskStatus from "./SwarmTaskStatus.generated.js";
+import * as SwarmVersion from "./SwarmVersion.generated.js";
+import * as SwarmVolumeAttachment from "./SwarmVolumeAttachment.generated.js";
+declare const SwarmTask_base: Schema.Class<SwarmTask, {
+    Spec: Schema.optionalWith<typeof SwarmTaskSpec.SwarmTaskSpec, {
+        nullable: true;
+    }>;
+    ServiceID: Schema.optional<typeof Schema.String>;
+    Slot: Schema.optional<typeof EffectSchemas.Number.I64>;
+    NodeID: Schema.optional<typeof Schema.String>;
+    Status: Schema.optionalWith<typeof SwarmTaskStatus.SwarmTaskStatus, {
+        nullable: true;
+    }>;
+    DesiredState: Schema.optional<Schema.Literal<["new", "allocated", "pending", "assigned", "accepted", "preparing", "ready", "starting", "running", "complete", "shutdown", "failed", "rejected", "remove", "orphaned"]>>;
+    NetworksAttachments: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmNetworkAttachment.SwarmNetworkAttachment>>, {
+        nullable: true;
+    }>;
+    GenericResources: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmGenericResource.SwarmGenericResource>>, {
+        nullable: true;
+    }>;
+    JobIteration: Schema.optionalWith<typeof SwarmVersion.SwarmVersion, {
+        nullable: true;
+    }>;
+    Volumes: Schema.NullOr<Schema.Array$<Schema.NullOr<typeof SwarmVolumeAttachment.SwarmVolumeAttachment>>>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    Version: Schema.optionalWith<typeof SwarmVersion.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 SwarmTaskSpec.SwarmTaskSpec, {
+        nullable: true;
+    }>;
+    ServiceID: Schema.optional<typeof Schema.String>;
+    Slot: Schema.optional<typeof EffectSchemas.Number.I64>;
+    NodeID: Schema.optional<typeof Schema.String>;
+    Status: Schema.optionalWith<typeof SwarmTaskStatus.SwarmTaskStatus, {
+        nullable: true;
+    }>;
+    DesiredState: Schema.optional<Schema.Literal<["new", "allocated", "pending", "assigned", "accepted", "preparing", "ready", "starting", "running", "complete", "shutdown", "failed", "rejected", "remove", "orphaned"]>>;
+    NetworksAttachments: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmNetworkAttachment.SwarmNetworkAttachment>>, {
+        nullable: true;
+    }>;
+    GenericResources: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmGenericResource.SwarmGenericResource>>, {
+        nullable: true;
+    }>;
+    JobIteration: Schema.optionalWith<typeof SwarmVersion.SwarmVersion, {
+        nullable: true;
+    }>;
+    Volumes: Schema.NullOr<Schema.Array$<Schema.NullOr<typeof SwarmVolumeAttachment.SwarmVolumeAttachment>>>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    Version: Schema.optionalWith<typeof SwarmVersion.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 Volumes: readonly (SwarmVolumeAttachment.SwarmVolumeAttachment | null)[] | null;
+} & {
+    readonly Labels: {
+        readonly [x: string]: string;
+    } | null;
+} & {
+    readonly Name?: string | undefined;
+} & {
+    readonly Status?: SwarmTaskStatus.SwarmTaskStatus | undefined;
+} & {
+    readonly Version?: SwarmVersion.SwarmVersion | undefined;
+} & {
+    readonly UpdatedAt?: Date | undefined;
+} & {
+    readonly Spec?: SwarmTaskSpec.SwarmTaskSpec | undefined;
+} & {
+    readonly NodeID?: string | undefined;
+} & {
+    readonly JobIteration?: SwarmVersion.SwarmVersion | undefined;
+} & {
+    readonly GenericResources?: readonly (SwarmGenericResource.SwarmGenericResource | null)[] | undefined;
+} & {
+    readonly ServiceID?: string | undefined;
+} & {
+    readonly Slot?: (bigint & import("effect/Brand").Brand<"I64">) | undefined;
+} & {
+    readonly DesiredState?: "starting" | "running" | "remove" | "pending" | "ready" | "new" | "allocated" | "assigned" | "accepted" | "preparing" | "complete" | "shutdown" | "failed" | "rejected" | "orphaned" | undefined;
+} & {
+    readonly NetworksAttachments?: readonly (SwarmNetworkAttachment.SwarmNetworkAttachment | null)[] | undefined;
+}, {}, {}>;
+export declare class SwarmTask extends SwarmTask_base {
+}
+export {};
+//# sourceMappingURL=SwarmTask.generated.d.ts.map

package/dist/internal/generated/SwarmTask.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmTask.generated.d.ts","sourceRoot":"","sources":["../../../src/internal/generated/SwarmTask.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,oBAAoB,MAAM,qCAAqC,CAAC;AAE5E,OAAO,KAAK,sBAAsB,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,aAAa,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,eAAe,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,YAAY,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,qBAAqB,MAAM,sCAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9E,qBAAa,SAAU,SAAQ,cA4C9B;CAAG"}