@wildo-ai/platform-core-shared 1.0.1 → 1.1.0

package/dist/esm/wildo-application-executions/wildo-application-executions.custom.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wildo-application-executions.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/wildo-application-executions/wildo-application-executions.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAGL,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAK/B;;;GAGG;AACH,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMzD,CAAC;AACH,MAAM,MAAM,uCAAuC,GACjD,CAAC,CAAC,KAAK,CAAC,OAAO,8CAA8C,CAAC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMxD,CAAC;AACH,MAAM,MAAM,sCAAsC,GAChD,CAAC,CAAC,KAAK,CAAC,OAAO,6CAA6C,CAAC,CAAC"}

package/dist/esm/wildo-application-executions/wildo-application-executions.custom.shared.schemas.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { ActorSystem_ExecutionSchema, FlowSystem_Execution_Schema, FlowsActors_Status, } from '@wildo-ai/saas-models';
+import { initZodDecorators } from '@wildo-ai/zod-decorators';
+initZodDecorators(z);
+/**
+ * Platform-owned actor executions are persisted in the apps-manager database but
+ * stay explicitly attached to the owning Wildo application row.
+ */
+export const Wildo_Application_ActorSystem_Execution_Schema = ActorSystem_ExecutionSchema.extend({
+    _id: z.string().min(1).isPrimaryKey().isSummaryField(),
+    organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),
+    wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),
+    systemRef: z.string().min(1).isDBIndexed().isSummaryField(),
+    status: z.enum(FlowsActors_Status).isDBIndexed().isSummaryField(),
+});
+/**
+ * Flow executions follow the same platform ownership chain as actor executions:
+ * org-scoped in the apps-manager DB and child-linked to a single Wildo app.
+ */
+export const Wildo_Application_FlowSystem_Execution_Schema = FlowSystem_Execution_Schema.extend({
+    _id: z.string().min(1).isPrimaryKey().isSummaryField(),
+    organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),
+    wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),
+    systemRef: z.string().min(1).isDBIndexed().isSummaryField(),
+    status: z.enum(FlowsActors_Status).isDBIndexed().isSummaryField(),
+});
+//# sourceMappingURL=wildo-application-executions.custom.shared.schemas.js.map

package/dist/esm/wildo-application-executions/wildo-application-executions.custom.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wildo-application-executions.custom.shared.schemas.js","sourceRoot":"","sources":["../../../../src/wildo-application-executions/wildo-application-executions.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAErB;;;GAGG;AACH,MAAM,CAAC,MAAM,8CAA8C,GAAG,2BAA2B,CAAC,MAAM,CAAC;IAC/F,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE;IACtD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAC5F,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAChG,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAC3D,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;CAClE,CAAC,CAAC;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,6CAA6C,GAAG,2BAA2B,CAAC,MAAM,CAAC;IAC9F,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE;IACtD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAC5F,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAChG,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAC3D,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;CAClE,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport {\n  ActorSystem_ExecutionSchema,\n  FlowSystem_Execution_Schema,\n  FlowsActors_Status,\n} from '@wildo-ai/saas-models';\nimport { initZodDecorators } from '@wildo-ai/zod-decorators';\n\ninitZodDecorators(z);\n\n/**\n * Platform-owned actor executions are persisted in the apps-manager database but\n * stay explicitly attached to the owning Wildo application row.\n */\nexport const Wildo_Application_ActorSystem_Execution_Schema = ActorSystem_ExecutionSchema.extend({\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n  organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  systemRef: z.string().min(1).isDBIndexed().isSummaryField(),\n  status: z.enum(FlowsActors_Status).isDBIndexed().isSummaryField(),\n});\nexport type Wildo_Application_ActorSystem_Execution =\n  z.infer<typeof Wildo_Application_ActorSystem_Execution_Schema>;\n\n/**\n * Flow executions follow the same platform ownership chain as actor executions:\n * org-scoped in the apps-manager DB and child-linked to a single Wildo app.\n */\nexport const Wildo_Application_FlowSystem_Execution_Schema = FlowSystem_Execution_Schema.extend({\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n  organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  systemRef: z.string().min(1).isDBIndexed().isSummaryField(),\n  status: z.enum(FlowsActors_Status).isDBIndexed().isSummaryField(),\n});\nexport type Wildo_Application_FlowSystem_Execution =\n  z.infer<typeof Wildo_Application_FlowSystem_Execution_Schema>;\n"]}

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.d.ts

@@ -0,0 +1,342 @@
+import { CoreResourceOperation, ResourceRelationship } from '@wildo-ai/saas-models';
+type WildoApplicationActorTasks_CoreOperations = CoreResourceOperation.CREATE | CoreResourceOperation.READ | CoreResourceOperation.LIST | CoreResourceOperation.UPDATE;
+/**
+ * Actor tasks are mutable control-plane records managed by the local companion,
+ * not public resource-controller surfaces. Repository-only CRUD keeps the
+ * framework persistence contract truthful without widening generated APIs.
+ */
+export declare const wildoApplicationActorTasks_ResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("@wildo-ai/saas-models").ResourceConfiguration<any, WildoApplicationActorTasks_CoreOperations, import("zod").ZodObject<{
+    description: import("zod").ZodString;
+    topic: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").Actor_Task_Topics>;
+    initiator: import("zod").ZodObject<{
+        organizationId: import("zod").ZodOptional<import("zod").ZodString>;
+        userId: import("zod").ZodOptional<import("zod").ZodString>;
+        applicationId: import("zod").ZodOptional<import("zod").ZodString>;
+        machineCredential: import("zod").ZodOptional<import("zod").ZodObject<{
+            authMethod: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
+            credentialId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        consumableTokenId: import("zod").ZodOptional<import("zod").ZodString>;
+        webhookProviderId: import("zod").ZodOptional<import("zod").ZodString>;
+        anonymousUserId: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    relationships: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.FLOW>;
+        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        flowId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.ACTOR>;
+        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        actorId: import("zod").ZodString;
+        actorSystemId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.FLOW_STEP>;
+        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        flowId: import("zod").ZodString;
+        stepId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.TASK>;
+        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        taskId: import("zod").ZodString;
+        actorSystemId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.PLAN>;
+        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        planId: import("zod").ZodString;
+        actorSystemId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.PLAN_STEP>;
+        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        planId: import("zod").ZodString;
+        planStepId: import("zod").ZodString;
+        actorSystemId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.ACTOR_SYSTEM>;
+        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        actorSystemId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>], "kind">>;
+    actors: import("zod").ZodObject<{
+        actorRef: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+    input: import("zod").ZodAny;
+    output: import("zod").ZodOptional<import("zod").ZodAny>;
+    memory: import("zod").ZodObject<{
+        shortTerm: import("zod").ZodObject<{
+            entries: import("zod").ZodArray<import("zod").ZodObject<{
+                key: import("zod").ZodString;
+                value: import("zod").ZodAny;
+                type: import("zod").ZodEnum<{
+                    json: "json";
+                    text: "text";
+                    binary: "binary";
+                }>;
+                timestamp: import("zod").ZodString;
+                expiresAt: import("zod").ZodOptional<import("zod").ZodString>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+            maxSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+            ttl: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        longTerm: import("zod").ZodObject<{
+            entries: import("zod").ZodArray<import("zod").ZodObject<{
+                key: import("zod").ZodString;
+                value: import("zod").ZodAny;
+                type: import("zod").ZodEnum<{
+                    json: "json";
+                    text: "text";
+                    binary: "binary";
+                }>;
+                timestamp: import("zod").ZodString;
+                expiresAt: import("zod").ZodOptional<import("zod").ZodString>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+            maxSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+            ttl: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        working: import("zod").ZodObject<{
+            entries: import("zod").ZodArray<import("zod").ZodObject<{
+                key: import("zod").ZodString;
+                value: import("zod").ZodAny;
+                type: import("zod").ZodEnum<{
+                    json: "json";
+                    text: "text";
+                    binary: "binary";
+                }>;
+                timestamp: import("zod").ZodString;
+                expiresAt: import("zod").ZodOptional<import("zod").ZodString>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+            maxSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+            ttl: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    context: import("zod").ZodObject<{
+        journeyId: import("zod").ZodOptional<import("zod").ZodString>;
+        playbookRef: import("zod").ZodOptional<import("zod").ZodString>;
+        playbookVersion: import("zod").ZodOptional<import("zod").ZodString>;
+        playbookRunId: import("zod").ZodOptional<import("zod").ZodString>;
+        stepRef: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    artifacts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        ref: import("zod").ZodString;
+        definitionRef: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        origin: import("zod").ZodObject<{
+            taskId: import("zod").ZodOptional<import("zod").ZodString>;
+            stepId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        createdAt: import("zod").ZodString;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        type: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_IO_PartKind.TEXT>;
+        content: import("zod").ZodObject<{
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            size: import("zod").ZodOptional<import("zod").ZodNumber>;
+            checksum: import("zod").ZodOptional<import("zod").ZodString>;
+            text: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ref: import("zod").ZodString;
+        definitionRef: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        origin: import("zod").ZodObject<{
+            taskId: import("zod").ZodOptional<import("zod").ZodString>;
+            stepId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        createdAt: import("zod").ZodString;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        type: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_IO_PartKind.FILE>;
+        content: import("zod").ZodObject<{
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            size: import("zod").ZodOptional<import("zod").ZodNumber>;
+            checksum: import("zod").ZodOptional<import("zod").ZodString>;
+            storage: import("zod").ZodObject<{
+                data: import("zod").ZodOptional<import("zod").ZodString>;
+                url: import("zod").ZodOptional<import("zod").ZodString>;
+                path: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ref: import("zod").ZodString;
+        definitionRef: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        origin: import("zod").ZodObject<{
+            taskId: import("zod").ZodOptional<import("zod").ZodString>;
+            stepId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        createdAt: import("zod").ZodString;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        type: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_IO_PartKind.RAW_DATA>;
+        content: import("zod").ZodObject<{
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            size: import("zod").ZodOptional<import("zod").ZodNumber>;
+            checksum: import("zod").ZodOptional<import("zod").ZodString>;
+            data: import("zod").ZodAny;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ref: import("zod").ZodString;
+        definitionRef: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        origin: import("zod").ZodObject<{
+            taskId: import("zod").ZodOptional<import("zod").ZodString>;
+            stepId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        createdAt: import("zod").ZodString;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        type: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_IO_PartKind.STRUCTURED>;
+        content: import("zod").ZodObject<{
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            size: import("zod").ZodOptional<import("zod").ZodNumber>;
+            checksum: import("zod").ZodOptional<import("zod").ZodString>;
+            data: import("zod").ZodAny;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ref: import("zod").ZodString;
+        definitionRef: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        origin: import("zod").ZodObject<{
+            taskId: import("zod").ZodOptional<import("zod").ZodString>;
+            stepId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        createdAt: import("zod").ZodString;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        type: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_IO_PartKind.IMAGE>;
+        content: import("zod").ZodObject<{
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            size: import("zod").ZodOptional<import("zod").ZodNumber>;
+            checksum: import("zod").ZodOptional<import("zod").ZodString>;
+            storage: import("zod").ZodObject<{
+                data: import("zod").ZodOptional<import("zod").ZodString>;
+                url: import("zod").ZodOptional<import("zod").ZodString>;
+                path: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            width: import("zod").ZodOptional<import("zod").ZodNumber>;
+            height: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>], "type">>>;
+    actorStates: import("zod").ZodArray<import("zod").ZodObject<{
+        actorRef: import("zod").ZodString;
+        status: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Status>;
+        updatedAt: import("zod").ZodString;
+        statusChanges: import("zod").ZodArray<import("zod").ZodObject<{
+            status: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Status>;
+            timestamp: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    errorStates: import("zod").ZodOptional<import("zod").ZodObject<{
+        circuitBreakerStatus: import("zod").ZodOptional<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_CircuitBreaker_Status>>;
+        errorItems: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            type: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ErrorType>;
+            severity: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ErrorSeverity>;
+            operationPathKey: import("zod").ZodOptional<import("zod").ZodString>;
+            timestamp: import("zod").ZodDate;
+            context: import("zod").ZodOptional<import("zod").ZodObject<{
+                message: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$catchall<import("zod").ZodAny>>>;
+            ipAddress: import("zod").ZodOptional<import("zod").ZodString>;
+            errorHandlingStrategy: import("zod").ZodOptional<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ErrorHandling_Strategy>>;
+            retryPolicy: import("zod").ZodOptional<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").RetryPolicy_BackoffType>>;
+            maxRetries: import("zod").ZodOptional<import("zod").ZodNumber>;
+            initialDelay: import("zod").ZodOptional<import("zod").ZodNumber>;
+            baseDelay: import("zod").ZodOptional<import("zod").ZodNumber>;
+            retryCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lastRetryTime: import("zod").ZodOptional<import("zod").ZodDate>;
+            backendActions: import("zod").ZodArray<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ErrorActionBackend>>;
+            customMessageReference: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ErrorCustomMessageReference>;
+            statusCode: import("zod").ZodNumber;
+            stack: import("zod").ZodOptional<import("zod").ZodString>;
+            correlationId: import("zod").ZodOptional<import("zod").ZodString>;
+            initiatorIds: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodObject<{
+                organizationId: import("zod").ZodOptional<import("zod").ZodString>;
+                userId: import("zod").ZodOptional<import("zod").ZodString>;
+                applicationId: import("zod").ZodOptional<import("zod").ZodString>;
+                machineCredential: import("zod").ZodOptional<import("zod").ZodObject<{
+                    authMethod: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
+                    credentialId: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+                consumableTokenId: import("zod").ZodOptional<import("zod").ZodString>;
+                webhookProviderId: import("zod").ZodOptional<import("zod").ZodString>;
+                anonymousUserId: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            executionType: import("zod").ZodOptional<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ExecutionContext_ExecutionType>>;
+            userGuidance: import("zod").ZodOptional<import("zod").ZodObject<{
+                guidanceKey: import("zod").ZodOptional<import("zod").ZodString>;
+                explanation: import("zod").ZodOptional<import("zod").ZodString>;
+                resolution: import("zod").ZodOptional<import("zod").ZodString>;
+                completedSteps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                nextAction: import("zod").ZodOptional<import("zod").ZodObject<{
+                    label: import("zod").ZodString;
+                    ref: import("zod").ZodString;
+                    type: import("zod").ZodDefault<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").NotificationNextStepType>>;
+                }, import("zod/v4/core").$strip>>;
+                retryAfterSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+                missingConfiguration: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strip>>;
+            actorRef: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>>;
+        checkpointChecks: import("zod").ZodArray<import("zod").ZodObject<{
+            checkpoint: import("zod").ZodObject<{
+                point: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.ACTOR>;
+                    actorId: import("zod").ZodString;
+                    actorSystemId: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.FLOW_STEP>;
+                    flowId: import("zod").ZodString;
+                    stepId: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.TASK>;
+                    taskId: import("zod").ZodString;
+                    actorSystemId: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.PLAN_STEP>;
+                    planId: import("zod").ZodString;
+                    planStepId: import("zod").ZodString;
+                    actorSystemId: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>], "kind">;
+                timestamp: import("zod").ZodString;
+                context: import("zod").ZodOptional<import("zod").ZodAny>;
+            }, import("zod/v4/core").$strip>;
+            timestamp: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        availableCheckpoints: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            point: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.ACTOR>;
+                actorId: import("zod").ZodString;
+                actorSystemId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.FLOW_STEP>;
+                flowId: import("zod").ZodString;
+                stepId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.TASK>;
+                taskId: import("zod").ZodString;
+                actorSystemId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.PLAN_STEP>;
+                planId: import("zod").ZodString;
+                planStepId: import("zod").ZodString;
+                actorSystemId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>], "kind">;
+            timestamp: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, import("zod/v4/core").$strip>>>;
+    }, import("zod/v4/core").$strip>>;
+    createdAt: import("zod").ZodString;
+    startedAt: import("zod").ZodOptional<import("zod").ZodString>;
+    completedAt: import("zod").ZodOptional<import("zod").ZodString>;
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>;
+    organizationId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>>>;
+    wildoApplicationId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>>>;
+    wildoApplicationActorSystemExecutionId: import("zod").ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>>;
+    continuityAttemptKey: import("zod").ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>>;
+    title: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>;
+    status: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Status>>>;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>>;
+export {};
+//# sourceMappingURL=wildo-application-tasks.custom.shared.resources-config.schemas.d.ts.map

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wildo-application-tasks.custom.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,EAGrB,oBAAoB,EAErB,MAAM,uBAAuB,CAAC;AAS/B,KAAK,yCAAyC,GAC1C,qBAAqB,CAAC,MAAM,GAC5B,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,MAAM,CAAC;AAWjC;;;;GAIG;AACH,eAAO,MAAM,sEAAsE,GAChF,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAwB7C,CAAC"}

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.js

@@ -0,0 +1,38 @@
+import { CORE_APP_ROLES, CoreResourceOperation, ResourceOperationRiskLevel, ResourceOperationVariantType, createResourceConfiguration_Initialization, } from '@wildo-ai/saas-models';
+import { CustomShared_ResourceFieldIdentifier, CustomShared_ResourceType, } from '../core/resources/resources-types.custom.shared.schemas.js';
+import { Wildo_Application_Actor_Task_Schema } from './wildo-application-tasks.custom.shared.schemas.js';
+const WildoApplicationActorTasks_Operations = undefined;
+function createRepositoryOnlyDefaultVariant() {
+    return {
+        variantType: ResourceOperationVariantType.REPOSITORY_ONLY,
+        isDefault: true,
+        roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],
+        riskLevel: ResourceOperationRiskLevel.LOW,
+    };
+}
+/**
+ * Actor tasks are mutable control-plane records managed by the local companion,
+ * not public resource-controller surfaces. Repository-only CRUD keeps the
+ * framework persistence contract truthful without widening generated APIs.
+ */
+export const wildoApplicationActorTasks_ResourceConfiguration_InitializationFactory = (resourcesRelationships) => createResourceConfiguration_Initialization({
+    mainSchema: Wildo_Application_Actor_Task_Schema,
+    resourceIdentifier: CustomShared_ResourceType.WILDO_APPLICATION_ACTOR_TASKS,
+    resourceFieldIdentifier: CustomShared_ResourceFieldIdentifier[CustomShared_ResourceType.WILDO_APPLICATION_ACTOR_TASKS],
+    resourceRelationships: resourcesRelationships,
+    isSystemResource: false,
+    coreOperations: [
+        CoreResourceOperation.CREATE,
+        CoreResourceOperation.READ,
+        CoreResourceOperation.LIST,
+        CoreResourceOperation.UPDATE,
+    ],
+    customOperation: WildoApplicationActorTasks_Operations,
+    operationsConfiguration: {
+        [CoreResourceOperation.CREATE]: { variants: [createRepositoryOnlyDefaultVariant()] },
+        [CoreResourceOperation.READ]: { variants: [createRepositoryOnlyDefaultVariant()] },
+        [CoreResourceOperation.LIST]: { variants: [createRepositoryOnlyDefaultVariant()] },
+        [CoreResourceOperation.UPDATE]: { variants: [createRepositoryOnlyDefaultVariant()] },
+    },
+});
+//# sourceMappingURL=wildo-application-tasks.custom.shared.resources-config.schemas.js.map

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wildo-application-tasks.custom.shared.resources-config.schemas.js","sourceRoot":"","sources":["../../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,0BAA0B,EAC1B,4BAA4B,EAE5B,0CAA0C,GAC3C,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,oCAAoC,EACpC,yBAAyB,GAC1B,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,mCAAmC,EAAE,MAAM,iDAAiD,CAAC;AAEtG,MAAM,qCAAqC,GAAG,SAAS,CAAC;AAQxD,SAAS,kCAAkC;IACzC,OAAO;QACL,WAAW,EAAE,4BAA4B,CAAC,eAAwB;QAClE,SAAS,EAAE,IAAa;QACxB,KAAK,EAAE,CAAC,cAAc,CAAC,qBAAqB,CAAC;QAC7C,SAAS,EAAE,0BAA0B,CAAC,GAAY;KACnD,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,sEAAsE,GACjF,CAAC,sBAA8C,EAAE,EAAE,CAAC,0CAA0C,CAI5F;IACA,UAAU,EAAE,mCAAmC;IAC/C,kBAAkB,EAAE,yBAAyB,CAAC,6BAA6B;IAC3E,uBAAuB,EACrB,oCAAoC,CAAC,yBAAyB,CAAC,6BAA6B,CAAC;IAC/F,qBAAqB,EAAE,sBAAsB;IAC7C,gBAAgB,EAAE,KAAK;IACvB,cAAc,EAAE;QACd,qBAAqB,CAAC,MAAM;QAC5B,qBAAqB,CAAC,IAAI;QAC1B,qBAAqB,CAAC,IAAI;QAC1B,qBAAqB,CAAC,MAAM;KAC7B;IACD,eAAe,EAAE,qCAAqC;IACtD,uBAAuB,EAAE;QACvB,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,kCAAkC,EAAE,CAAC,EAAE;QACpF,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,kCAAkC,EAAE,CAAC,EAAE;QAClF,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,kCAAkC,EAAE,CAAC,EAAE;QAClF,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,kCAAkC,EAAE,CAAC,EAAE;KACrF;CACF,CAAC,CAAC","sourcesContent":["import {\n  CORE_APP_ROLES,\n  CoreResourceOperation,\n  ResourceOperationRiskLevel,\n  ResourceOperationVariantType,\n  ResourceRelationship,\n  createResourceConfiguration_Initialization,\n} from '@wildo-ai/saas-models';\nimport {\n  CustomShared_ResourceFieldIdentifier,\n  CustomShared_ResourceType,\n} from '../core/resources/resources-types.custom.shared.schemas';\nimport { Wildo_Application_Actor_Task_Schema } from './wildo-application-tasks.custom.shared.schemas';\n\nconst WildoApplicationActorTasks_Operations = undefined;\n\ntype WildoApplicationActorTasks_CoreOperations =\n  | CoreResourceOperation.CREATE\n  | CoreResourceOperation.READ\n  | CoreResourceOperation.LIST\n  | CoreResourceOperation.UPDATE;\n\nfunction createRepositoryOnlyDefaultVariant() {\n  return {\n    variantType: ResourceOperationVariantType.REPOSITORY_ONLY as const,\n    isDefault: true as const,\n    roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],\n    riskLevel: ResourceOperationRiskLevel.LOW as const,\n  };\n}\n\n/**\n * Actor tasks are mutable control-plane records managed by the local companion,\n * not public resource-controller surfaces. Repository-only CRUD keeps the\n * framework persistence contract truthful without widening generated APIs.\n */\nexport const wildoApplicationActorTasks_ResourceConfiguration_InitializationFactory =\n  (resourcesRelationships: ResourceRelationship[]) => createResourceConfiguration_Initialization<\n    typeof WildoApplicationActorTasks_Operations,\n    WildoApplicationActorTasks_CoreOperations,\n    typeof Wildo_Application_Actor_Task_Schema\n  >({\n    mainSchema: Wildo_Application_Actor_Task_Schema,\n    resourceIdentifier: CustomShared_ResourceType.WILDO_APPLICATION_ACTOR_TASKS,\n    resourceFieldIdentifier:\n      CustomShared_ResourceFieldIdentifier[CustomShared_ResourceType.WILDO_APPLICATION_ACTOR_TASKS],\n    resourceRelationships: resourcesRelationships,\n    isSystemResource: false,\n    coreOperations: [\n      CoreResourceOperation.CREATE,\n      CoreResourceOperation.READ,\n      CoreResourceOperation.LIST,\n      CoreResourceOperation.UPDATE,\n    ],\n    customOperation: WildoApplicationActorTasks_Operations,\n    operationsConfiguration: {\n      [CoreResourceOperation.CREATE]: { variants: [createRepositoryOnlyDefaultVariant()] },\n      [CoreResourceOperation.READ]: { variants: [createRepositoryOnlyDefaultVariant()] },\n      [CoreResourceOperation.LIST]: { variants: [createRepositoryOnlyDefaultVariant()] },\n      [CoreResourceOperation.UPDATE]: { variants: [createRepositoryOnlyDefaultVariant()] },\n    },\n  });\n"]}